formatting and lint fixes, entry point for new llvm backend

yangdanny97 · yangdanny97 · commit fadec95eda44 · 2023-05-14T00:07:06.000-07:00
diff --git a/compiler/builder.py b/compiler/builder.py
@@ -5,7 +5,7 @@ def __init__(self, name: str):
         self.indentation = 0
 
     def newLine(self, line=""):
-        self.lines.append((self.indentation*"    ") + line)
+        self.lines.append((self.indentation * "    ") + line)
         return self
 
     # returns a reference to the child builder
diff --git a/compiler/cil_backend.py b/compiler/cil_backend.py
@@ -41,11 +41,11 @@ def currentBuilder(self):
 
     def newLabelName(self) -> str:
         self.counter += 1
-        return "IL_"+str(self.counter)
+        return "IL_" + str(self.counter)
 
     def label(self, name: str) -> str:
         self.builder.unindent()
-        self.instr(name+": nop")
+        self.instr(name + ": nop")
         self.builder.indent()
 
     def store(self, name: str):
@@ -212,7 +212,7 @@ def constructor(superclass: str, func: FuncDef):
                 # method
                 d.type = d.type.dropFirstParam()
                 self.FuncDef(d, "virtual instance")
-        if constructor_def == None:
+        if constructor_def is None:
             # give a default constructor if none exists
             funcDef = node.getDefaultConstructor()
             constructor(superclass, funcDef)
diff --git a/compiler/compiler.py b/compiler/compiler.py
@@ -82,3 +82,6 @@ def emitWASM(self, main: str, ast: Node):
         wasm_backend = WasmBackend(main, self.transformer.ts)
         wasm_backend.visit(ast)
         return wasm_backend.builder
+
+    def emitLLVM(self, main: str, ast: Node):
+        pass
diff --git a/compiler/empty_list_typer.py b/compiler/empty_list_typer.py
@@ -59,7 +59,7 @@ def AssignStmt(self, node: AssignStmt):
         self.expectedType = node.targets[0].inferredType
 
     def ListExpr(self, node: ListExpr):
-        if self.expectedType == None:
+        if self.expectedType is None:
             return
         expType = self.expectedType
         if isinstance(self.expectedType, ListValueType) and len(node.elements) == 0:
diff --git a/compiler/jvm_backend.py b/compiler/jvm_backend.py
@@ -25,11 +25,11 @@ def currentBuilder(self):
 
     def newLabelName(self) -> str:
         self.counter += 1
-        return "L"+str(self.counter)
+        return "L" + str(self.counter)
 
     def label(self, name: str) -> str:
         self.currentBuilder().unindent()
-        self.instr(name+":")
+        self.instr(name + ":")
         self.currentBuilder().indent()
 
     def returnInstr(self, exprType: ValueType):
@@ -186,7 +186,7 @@ def ClassDef(self, node: ClassDef):
                 self.constructor(superclass, d)
             else:
                 self.method(d)
-        if constructor_def == None:
+        if constructor_def is None:
             funcDef = node.getDefaultConstructor()
             self.constructor(superclass, funcDef)
         self.instr(".end class")
@@ -671,7 +671,8 @@ def emit_input(self):
             "invokespecial Method java/util/Scanner <init> (Ljava/io/InputStream;)V")
         l = self.newLocal()
         self.instr(f"aload {l}")
-        self.instr("invokevirtual Method java/util/Scanner nextLine ()Ljava/lang/String;")
+        self.instr(
+            "invokevirtual Method java/util/Scanner nextLine ()Ljava/lang/String;")
 
     def emit_len(self, arg: Expr):
         t = arg.inferredType
diff --git a/compiler/parser.py b/compiler/parser.py
@@ -74,7 +74,7 @@ def visit_Module(self, node):
                 if (isinstance(body[i], GlobalDecl) or isinstance(body[i], NonLocalDecl)):
                     raise ParseError(
                         "Expected function, class, or variable declaration", node.body[i])
-                if decl == False:
+                if not decl:
                     raise ParseError(
                         "All declarations must come before statements", node.body[i])
                 declarations.append(b)
@@ -105,7 +105,7 @@ def visit_FunctionDef(self, node):
                 if isinstance(b, ClassDef):
                     raise ParseError(
                         "Inner classes are unsupported", node.body[i])
-                if decl == False:
+                if not decl:
                     raise ParseError(
                         "All declarations must come before statements", node.body[i])
                 declarations.append(b)
@@ -143,7 +143,7 @@ def visit_ClassDef(self, node):
                              node.decorator_list[0])
         body = [self.visit(b) for b in node.body]
         # allow class bodies that only contain a single pass
-        if len(body) == 1 and body[0] == None:
+        if len(body) == 1 and body[0] is None:
             body = []
         else:
             for i in range(len(body)):
@@ -156,7 +156,7 @@ def visit_ClassDef(self, node):
 
     def visit_Return(self, node):
         location = self.getLocation(node)
-        if node.value == None:
+        if node.value is None:
             return ReturnStmt(location, None)
         else:
             return ReturnStmt(location, self.visit(node.value))
@@ -288,7 +288,7 @@ def visit_Constant(self, node):
             return BooleanLiteral(location, node.value)
         elif isinstance(node.value, int):
             return IntegerLiteral(location, node.value)
-        elif isinstance(node.value, str) and node.kind == None:
+        elif isinstance(node.value, str) and node.kind is None:
             return StringLiteral(location, node.value)
         elif node.value is None:
             return NoneLiteral(location)
@@ -335,7 +335,7 @@ def visit_List(self, node):
 
     def visit_NameConstant(self, node):
         location = self.getLocation(node)
-        if node.value == None:
+        if node.value is None:
             return NoneLiteral(location)
         elif isinstance(node.value, bool):
             return BooleanLiteral(location, node.value)
diff --git a/compiler/typechecker.py b/compiler/typechecker.py
@@ -283,7 +283,7 @@ def AssignStmt(self, node: AssignStmt):
         else:
             for t in node.targets:
                 if isinstance(t, IndexExpr) and t.list.inferredType == StrType():
-                    self.addError(t, F"Cannot assign to index of string")
+                    self.addError(t, "Cannot assign to index of string")
                     return
                 if isinstance(t, Identifier) and not self.defInCurrentScope(t.name):
                     self.addError(
diff --git a/compiler/types/classvaluetype.py b/compiler/types/classvaluetype.py
@@ -86,7 +86,7 @@ def getCILName(self):
         elif self.className == "int":
             return "int64"
         else:
-            return "class "+self.className
+            return "class " + self.className
 
     def getWasmName(self):
         # bools are i32, ints are i64
diff --git a/compiler/types/functype.py b/compiler/types/functype.py
@@ -61,7 +61,8 @@ def getWasmSignature(self, names=None) -> str:
                 sig = f"(param {paramName} {p.getWasmName()})"
             params.append(sig)
         params = " ".join(params)
-        result = "" if self.returnType.isNone() else f" (result {self.returnType.getWasmName()})"
+        result = "" if self.returnType.isNone(
+        ) else f" (result {self.returnType.getWasmName()})"
         return params + result
 
     def methodEquals(self, other):
diff --git a/compiler/types/listvaluetype.py b/compiler/types/listvaluetype.py
@@ -12,10 +12,10 @@ def __eq__(self, other):
         return False
 
     def getJavaSignature(self, _=False):
-        return "["+self.elementType.getJavaSignature(True)
+        return "[" + self.elementType.getJavaSignature(True)
 
     def getJavaName(self, _=False):
-        return "["+self.elementType.getJavaSignature(True)
+        return "[" + self.elementType.getJavaSignature(True)
 
     def getCILName(self, _=False):
         return self.elementType.getCILName() + "[]"
diff --git a/compiler/typesystem.py b/compiler/typesystem.py
@@ -116,8 +116,7 @@ def canAssign(self, a: ValueType, b: ValueType) -> bool:
             return True
         if isinstance(b, ListValueType) and a == EmptyType():
             return True
-        if (isinstance(b, ListValueType) and isinstance(a, ListValueType)
-                and a.elementType == NoneType()):
+        if (isinstance(b, ListValueType) and isinstance(a, ListValueType) and a.elementType == NoneType()):
             return self.canAssign(a.elementType, b.elementType)
         return False
 
@@ -148,30 +147,33 @@ def join(self, a: ValueType, b: ValueType):
         bAncestors = bAncestors[::-1]
         for i in range(min(len(aAncestors), len(bAncestors))):
             if aAncestors[i] != bAncestors[i]:
-                return self.classes[aAncestors[i-1]]
+                return self.classes[aAncestors[i - 1]]
         # this really shouldn't be returned
         return ObjectType()
 
     def getOrderedMethods(self, className: str):
         # (name, signature, defined in class)
         methods = []
         if self.classes[className].superclass is not None:
-            methods = self.getOrderedMethods(self.classes[className].superclass)
+            methods = self.getOrderedMethods(
+                self.classes[className].superclass)
         for name in self.classes[className].methods:
             hasExisting = False
             for i in range(len(methods)):
                 if methods[i][0] == name:
-                    methods[i] = (name, self.classes[className].methods[name], className)
+                    methods[i] = (
+                        name, self.classes[className].methods[name], className)
                     hasExisting = True
                     break
             if not hasExisting:
-                methods.append((name, self.classes[className].methods[name], className))
+                methods.append(
+                    (name, self.classes[className].methods[name], className))
         return methods
 
     def getMappedMethods(self, className: str):
         # map of name -> signature, defined in class
         ordered = self.getOrderedMethods(className)
-        return { x: (y, z) for x, y, z in ordered }
+        return {x: (y, z) for x, y, z in ordered}
 
     def getOrderedAttrs(self, className: str):
         # return list of (name, type, init value) triples
@@ -186,4 +188,4 @@ def getOrderedAttrs(self, className: str):
     def getMappedAttrs(self, className: str):
         # map of name -> type, init value tuples
         ordered = self.getOrderedAttrs(className)
-        return { x: (y, z) for x, y, z in ordered }
+        return {x: (y, z) for x, y, z in ordered}
diff --git a/compiler/wasm_backend.py b/compiler/wasm_backend.py
diff --git a/main.py b/main.py
diff --git a/test.py b/test.py
