onelang/langs/csharp.yaml

OneLang transpiler framework core

name: csharp
extension: cs
casing: # based on https://msdn.microsoft.com/en-us/library/x2dbyw72(v=vs.71).aspx
  class: pascal_case
  method: pascal_case
  enum: pascal_case
  enumMember: pascal_case
  variable: camel_case
  field: pascal_case # TODO: private
  property: pascal_case
primitiveTypes:
  void: void
  any: object
templates:
  testGenerator: |-
    public class Program
    {
        static public void Main(string[] args)
        {
            try 
            {
                new {{class}}().{{method}}();
            }
            catch (System.Exception e)
            {
                System.Console.WriteLine($"Exception: {e.Message}");
            }
        }
    }

  main: |-
    {{for inc in includes|sep=\n}}
      using {{inc.name}};
    {{/for}}

    {{for enum in enums|sep=\n}}
      public enum {{enum.name}} { 
      {{for item in enum.values|inline sep=", "}}
        {{item.name}}
      {{/for}}
       }
    {{/for}}

    {{for interface in interfaces|sep=\n\n}}
      public interface {{genTypeArgs(interface)}}
      {
          {{for method in interface.methods|sep="\n    \n"}}
            {{method.returnType}} {{method.name}}({{genArgs(method)}});
          {{/for}}
      }
    {{/for}}
    
    {{for class in classes|sep=\n\n}}
      public class {{genTypeArgs(class)}}
      {
          {{beforeFields(class)}}

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

          {{if class.constructor}}
            public {{class.name}}({{genArgs(class.constructor)}})
            {
                {{genBody(class.constructor.body)}}
            }
          {{/if}}

          {{for method in class.methods|sep="\n    \n"}}
            {{method.visibility}} {{if method.attributes["virtual"]}}virtual {{/if}}{{if method.attributes["override"]}}override {{/if}}{{if method.static}}static {{/if}}{{method.returnType}} {{method.name}}({{genArgs(method)}})
            {
                {{genBody(method.body)}}
            }
          {{/for}}
      }
    {{/for}}

    {{if mainBlock.statements.length > 0}}
      public class Program
      {
          static public void Main(string[] args)
          {
              {{genBody(mainBlock)}}
          }
      }
    {{/if}}
    
  genTypeArgs:
    args: [{name: class}]
    template: |-
      {{class.name}}
      {{if class.typeArguments|inline}}
        <
        {{for arg in class.typeArguments|inline sep=", "}}
          {{arg}}
        {{/for}}
        >
      {{/if}}
      {{if class.baseClasses.length > 0|inline}}
        : 
        {{for item in class.baseClasses|inline sep=", "}}
          {{item}}
        {{/for}}
      {{/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.type}} {{param.name}}
      {{/for}}
  genParams:
    args:
      - name: params
    template: |-
      {{for param in params|sep=", " inline}}
        {{gen(param)}}
      {{/for}}
  genVar:
    args:
      - name: itemVar
    template: "{{if itemVar.isUnused}}/* UNUSED: {{/if}}var {{itemVar.outName}} = {{if itemVar.isUnused}}*/ {{/if}}{{gen(itemVar.initializer)}}"
  genWithParen:
    args: [{ name: expr }]
    template: |-
      {{if expr.exprKind == "Binary" or expr.exprKind == "Conditional"}}
        ({{gen(expr)}})
      {{else}}
        {{gen(expr)}}
      {{/if}}
  beforeFields: { args: [class], template: "" }
expressions:
  call: "{{gen(expr.method)}}({{genParams(expr.arguments)}})"
  propertyAccess: "{{gen(expr.object)}}.{{gen(expr.propertyName)}}"
  identifier: "{{expr.text}}"
  stringLiteral: '"{{expr.escapedText}}"'
  characterLiteral: "'{{expr.escapedTextSingle}}'"
  numericLiteral: "{{expr.value}}"
  nullLiteral: "null"
  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: "throw {{gen(expr.expression)}};"
  parenthesized: "({{gen(expr.expression)}})"
  variableDeclaration: "{{genVar(expr)}};"
  new: |-
    new {{gen(expr.cls)}}
    {{if expr.typeArguments.length > 0|inline}}
      <
      {{for arg in expr.typeArguments|inline sep=", "}}
        {{typeName(arg)}}
      {{/for}}
      >
    {{/if}}
    ({{genParams(expr.arguments)}})
  classReference: "{{expr.classRef.outName}}"
  enumReference: "{{expr.enumRef.outName}}"
  enumMemberReference: "{{expr.enumRef.outName}}.{{expr.enumMemberRef.outName}}"
  expressionStatement: "{{gen(expr.expression)}};"
  instanceMethod: "{{gen(expr.thisExpr)}}.{{expr.methodRef.outName}}"
  staticMethod: "{{expr.methodRef.classRef.outName}}.{{expr.methodRef.outName}}"
  localVar: "{{expr.varRef.outName}}"
  methodArgument: "{{expr.varRef.outName}}"
  instanceField: "{{gen(expr.thisExpr)}}.{{expr.varRef.outName}}"
  staticField: "{{if expr.thisExpr.exprKind != 'ThisReference'}}{{gen(expr.thisExpr)}}.{{/if}}{{expr.varRef.outName}}"
  falseLiteral: "false"
  trueLiteral: "true"
  elementAccess: "{{gen(expr.object)}}[{{gen(expr.elementExpr)}}]"
  thisReference: this
  cast: "({{typeName(expr.newType)}})({{gen(expr.expression)}})"
  conditional: "{{gen(expr.condition)}} ? {{gen(expr.whenTrue)}} : {{gen(expr.whenFalse)}}"
  break: break;
  templateString: |-
    $"
    {{for part in expr.parts|inline}}
      {{if part.literal|inline}}
        {{escapeQuotes(part.text)}}
      {{else}}
        {{if part.expr.valueType.isBoolean|inline}}
          {({{genWithParen(part.expr)}} ? "true" : "false")}
        {{else}}
          {{{gen(part.expr)}}}
        {{/if}}
      {{/if}}
    {{/for}}
    "
  foreach: |-
    foreach (var {{expr.itemVariable.outName}} in {{gen(expr.items)}})
    {
        {{genBody(expr.body)}}
    }
  for: |-
    for ({{genVar(expr.itemVariable)}}; {{gen(expr.condition)}}; {{gen(expr.incrementor)}})
    {
        {{genBody(expr.body)}}
    }
  while: |-
    while ({{gen(expr.condition)}})
    {
        {{genBody(expr.body)}}
    }
  if: |-
    if ({{gen(expr.condition)}})
    {
        {{genBody(expr.then)}}
    }
    {{if expr.else}}
      {{if isIfBlock(expr.else)}}
        else {{genBody(expr.else)|inline}}
      {{else}}
        else
        {
            {{genBody(expr.else)}}
        }
      {{/if}}
    {{/if}}