Stub out a little more of the C# backend

3 files changed, 125 insertions, 15 deletions

diff --git a/src/main/java/org/zwobble/couscous/ast/MethodNode.java b/src/main/java/org/zwobble/couscous/ast/MethodNode.java
index 86ae649..1a53b64 100644
--- a/src/main/java/org/zwobble/couscous/ast/MethodNode.java
+++ b/src/main/java/org/zwobble/couscous/ast/MethodNode.java
@@ -71,11 +71,11 @@ public class MethodNode implements CallableNode {
     }
     
     public static MethodNode method(
-            List<AnnotationNode> annotations,
-            boolean isStatic,
-            String name,
-            List<FormalArgumentNode> arguments, 
-            List<StatementNode> body) {
+        List<AnnotationNode> annotations,
+        boolean isStatic,
+        String name,
+        List<FormalArgumentNode> arguments,
+        List<StatementNode> body) {
         return new MethodNode(annotations, isStatic, name, arguments, body);
     }
     
diff --git a/src/main/java/org/zwobble/couscous/ast/TypeName.java b/src/main/java/org/zwobble/couscous/ast/TypeName.java
index 4ff70ed..e2c32d0 100644
--- a/src/main/java/org/zwobble/couscous/ast/TypeName.java
+++ b/src/main/java/org/zwobble/couscous/ast/TypeName.java
@@ -2,6 +2,8 @@ package org.zwobble.couscous.ast;
 
 import com.google.common.base.Strings;
 
+import java.util.Optional;
+
 public class TypeName {
     public static TypeName of(String qualifiedName) {
         if (Strings.isNullOrEmpty(qualifiedName)) {
@@ -24,6 +26,15 @@ public class TypeName {
         return qualifiedName.substring(qualifiedName.lastIndexOf(".") + 1);
     }
 
+    public Optional<String> getPackage() {
+        int lastDot = qualifiedName.lastIndexOf(".");
+        if (lastDot == -1) {
+            return Optional.empty();
+        } else {
+            return Optional.of(qualifiedName.substring(0, lastDot));
+        }
+    }
+
     @Override
     public String toString() {
         return "TypeName(qualifiedName=" + qualifiedName + ")";
diff --git a/src/main/java/org/zwobble/couscous/backends/csharp/CsharpBackend.java b/src/main/java/org/zwobble/couscous/backends/csharp/CsharpBackend.java
index 3f6c8a7..f8a2d50 100644
--- a/src/main/java/org/zwobble/couscous/backends/csharp/CsharpBackend.java
+++ b/src/main/java/org/zwobble/couscous/backends/csharp/CsharpBackend.java
@@ -1,14 +1,16 @@
 package org.zwobble.couscous.backends.csharp;
 
 import org.zwobble.couscous.Backend;
-import org.zwobble.couscous.ast.ClassNode;
+import org.zwobble.couscous.ast.*;
+import org.zwobble.couscous.ast.visitors.ExpressionNodeMapper;
+import org.zwobble.couscous.values.PrimitiveValueVisitor;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
 
-import static org.zwobble.couscous.util.ExtraLists.list;
+import static com.google.common.collect.Iterables.transform;
 
 public class CsharpBackend implements Backend {
     private final Path directoryPath;
@@ -21,14 +23,111 @@ public class CsharpBackend implements Backend {
 
     @Override
     public void compile(List<ClassNode> classes) throws IOException {
-        Files.write(directoryPath.resolve("Program.cs"), list(
-            "namespace " + namespace + "{" +
-            "    class Program {" +
-            "        public static string run() {" +
-            "            return \"T\";" +
-            "        }" +
-            "    }" +
-            "}"
+        Files.write(
+            directoryPath.resolve("Program.cs"),
+            transform(
+                classes,
+                classNode -> compileClass(classNode)
         ));
     }
+
+    private String compileClass(ClassNode classNode) {
+        String namespace = this.namespace +
+            classNode.getName().getPackage()
+                .map(packageName -> packageName + ".")
+                .orElse("");
+        return "namespace " + namespace + " {" +
+            "    public class " + classNode.getSimpleName() + " {" +
+            String.join("\n", transform(classNode.getMethods(), method -> compileMethod(method))) +
+            "    }" +
+            "}";
+    }
+
+    private String compileMethod(MethodNode method) {
+        ReturnNode returnNode = (ReturnNode) method.getBody().get(0);
+        return
+            "public static string " + method.getName() + "() {" +
+            "    return " + compileExpression(returnNode.getValue()) + ";" +
+            "}";
+    }
+
+    private String compileExpression(ExpressionNode value) {
+        return value.accept(new ExpressionNodeMapper<String>() {
+            @Override
+            public String visit(LiteralNode literal) {
+                return literal.getValue().accept(new PrimitiveValueVisitor<String>() {
+                    @Override
+                    public String visitInteger(int value) {
+                        return Integer.toString(value);
+                    }
+
+                    @Override
+                    public String visitString(String value) {
+                        // TODO: escaping
+                        return "\"" + value + "\"";
+                    }
+
+                    @Override
+                    public String visitBoolean(boolean value) {
+                        return value ? "true" : "false";
+                    }
+
+                    @Override
+                    public String visitUnit() {
+                        throw new UnsupportedOperationException();
+                    }
+
+                    @Override
+                    public String visitType(TypeName value) {
+                        throw new UnsupportedOperationException();
+                    }
+                });
+            }
+
+            @Override
+            public String visit(VariableReferenceNode variableReference) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public String visit(ThisReferenceNode reference) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public String visit(AssignmentNode assignment) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public String visit(TernaryConditionalNode ternaryConditional) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public String visit(MethodCallNode methodCall) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public String visit(ConstructorCallNode call) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public String visit(FieldAccessNode fieldAccess) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public String visit(TypeCoercionNode typeCoercion) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public String visit(CastNode cast) {
+                throw new UnsupportedOperationException();
+            }
+        });
+    }
 }