onelang/langs/go.yaml

OneLang transpiler framework core

name: go
extension: go
casing: # based on https://golang.org/doc/effective_go.html#mixed-caps
  class: pascal_case
  method: pascal_case
  field: pascal_case # TODO: private
  variable: camel_case # TODO: private
  property: pascal_case # TODO: private
  enum: pascal_case
  enumMember: upper_case
primitiveTypes:
  void: ""
  any: "interface{}"
genericsOverride: interface{}
templates:
  testGenerator: |-
    func main() {
        defer func() {
          if r := recover(); r != nil {
              fmt.Print("Exception: ", r)
          }
        }()

        c := New{{class}}()
        c.{{method}}();
    }

  main: |-
    package main

    import "fmt"
    {{for inc in includes|sep=\n}}
      import "{{inc.name}}"
    {{/for}}


    {{for enum in enums|sep=\n\n}}
      type {{enum.name}} int
      const (
          {{for item in enum.values}}
            {{enum.name}}_{{item.name}} = {{item.intValue}}
          {{/for}}
      )
    {{/for}}

    {{for interface in interfaces|sep=\n\n}}
      type {{interface.name}} interface {
          {{for baseIntf in interface.baseInterfaces}}
            {{baseIntf}}
          {{/for}}
          {{for method in interface.methods|sep=\n\n}}
            {{method.name}}({{genArgs(method)}}) 
            {{if method.returnType|inline}}
              {{getType(method.returnTypeInfo)}} 
            {{/if}}
          {{/for}}
      }
    {{/for}}
    
    {{for class in classes|sep=\n\n}}
      type {{class.name}} struct {
          {{if class.baseClass}}
            {{class.baseClass}}
          {{/if}}
          {{for field in class.instanceFields|sep=\n}}
            {{field.name}} {{getType(field.typeInfo)}}
          {{/for}}
      }

      func New{{class.name}}({{if class.constructor}}{{genArgs(class.constructor)}}{{/if}}) *{{class.name}} {
          this := new({{class.name}})
          {{for field in class.fields|sep=\n}}
            {{if field.static == false && field.initializer}}
              this.{{field.name}} = {{gen(field.initializer)}}
            {{/if}}
          {{/for}}
          {{if class.constructor}}
            {{genBody(class.constructor.body)}}
          {{/if}}
          return this
      }

      {{for method in class.methods|sep=\n\n}}
        func 
        {{if method.static|inline}}
          {{class.name}}_{{method.name}}
        {{else}}
          (this *{{class.name}}) {{method.name}}
        {{/if}}
        ({{genArgs(method)}}) 
        {{if method.returnType|inline}}
          {{getType(method.returnTypeInfo)}} 
        {{/if}}
        {
            {{genBody(method.body)}}
        }
      {{/for}}

      {{for field in class.staticFields|sep=\n}}
        var {{class.name}}{{field.name}} {{field.type}}{{if field.initializer}} = {{gen(field.initializer)}}{{/if}};
      {{/for}}
    {{/for}}

    {{afterClasses()}}

    {{if mainBlock.statements.length > 0}}
      func main() {
          {{genBody(mainBlock)}}
      }
    {{/if}}

  getType:
    args:
      - name: item
    template: |-
      {{if item.isComplexClass && !item.isOneArray &&!item.isInterface}}
        *{{typeName(item)}}
      {{elif item.isOneArray}}
        []{{getType(item.typeArguments[0])}}
      {{else}}
        {{typeName(item)}}
      {{/if}}

  genBody:
    args:
      - name: body
    template: |-
      {{for statement in body.statements|sep=\n}}
        {{statement.leadingTrivia}}{{gen(statement)}}
      {{/for}}

  genArgs:
    args:
      - name: method
    template: |-
      {{for param in method.parameters|sep=", "}}
        {{param.name}} {{param.type}}
      {{/for}}
  genParams:
    args:
      - name: params
    template: |-
      {{for param in params|sep=", " inline}}
        {{gen(param)}}
      {{/for}}
  genVar:
    args:
      - name: itemVar
    template: "{{itemVar.outName}} := {{gen(itemVar.initializer)}}"
expressions:
  call: |-
    {{gen(expr.method)}}(
      {{for arg in expr.arguments|sep=", " inline}}
        {{gen(arg)}}
      {{/for}}
    )
  propertyAccess: "{{gen(expr.object)}}.{{gen(expr.propertyName)}}"
  identifier: "{{expr.text}}"
  stringLiteral: '"{{expr.escapedText}}"'
  characterLiteral: "'{{expr.escapedTextSingle}}'"
  nullLiteral: "nil"
  return: "return{{if expr.expression}} {{gen(expr.expression)}}{{/if}}"
  binary: "{{gen(expr.left)}} {{expr.operator}} {{gen(expr.right)}}"
  postfix: "{{gen(expr.operand)}}{{expr.operator}}"
  prefix: "{{expr.operator}}{{gen(expr.operand)}}"
  throw: "panic({{gen(expr.expression)}});"
  parenthesized: "({{gen(expr.expression)}})"
  numericLiteral: "{{expr.value}}"
  variableDeclaration: "{{genVar(expr)}}"
  new: "New{{gen(expr.cls)}}({{genParams(expr.arguments)}})"
  classReference: "{{clsName(expr.classRef)}}"
  enumMemberReference: "{{expr.enumRef.outName}}_{{expr.enumMemberRef.outName}}"
  expressionStatement: "{{gen(expr.expression)}}"
  instanceMethod: "{{gen(expr.thisExpr)}}.{{expr.methodRef.outName}}"
  staticMethod: "{{clsName(expr.methodRef.classRef)}}_{{expr.methodRef.outName}}"
  localVar: "{{expr.varRef.outName}}"
  methodArgument: "{{expr.varRef.outName}}"
  instanceField: "{{gen(expr.thisExpr)}}.{{expr.varRef.outName}}"
  staticField: "{{gen(expr.thisExpr)}}{{expr.varRef.outName}}"
  falseLiteral: "false"
  trueLiteral: "true"
  elementAccess: "{{gen(expr.object)}}[{{gen(expr.elementExpr)}}]"
  thisReference: this
  break: break
  templateString: |-
    fmt.Sprintf("
    {{for part in expr.parts|inline}}
      {{if part.literal|inline}}
        {{escapeQuotes(part.text)}}
      {{else}}
        %v
      {{/if}}
    {{/for}}
    "
    {{for part in expr.parts|inline}}
      {{if part.expr|inline}}
        , {{gen(part.expr)}}
      {{/if}}
    {{/for}}
    )
  conditional: |-
    var {{result}} {{typeName(expr.valueType)}}
    if {{gen(expr.condition)}} {
      {{result}} = {{gen(expr.whenTrue)}}
    } else {
      {{result}} = {{gen(expr.whenFalse)}}
    }
  foreach: |-
    for _, {{expr.itemVariable.outName}} := range {{gen(expr.items)}} {
        {{genBody(expr.body)}}
    }
  for: |-
    for {{genVar(expr.itemVariable)}}; {{gen(expr.condition)}}; {{gen(expr.incrementor)}} {
        {{genBody(expr.body)}}
    }
  while: |-
    for {{gen(expr.condition)}} {
        {{genBody(expr.body)}}
    }
  if: |-
    if {{gen(expr.condition)}} {
        {{genBody(expr.then)}}
    }
    {{if expr.else|inline}}
      {{" "}}
      {{if isIfBlock(expr.else)|inline}}
        else {{genBody(expr.else)}}
      {{else}}
        else {
            {{genBody(expr.else)}}
        }
      {{/if}}
    {{/if}}