Initial commit

src/main/java/chocopy/common/astnodes/AssignStmt.java

@@ -0,0 +1,25 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.List;
+
+/** Single and multiple assignments. */
+public class AssignStmt extends Stmt {
+    /** List of left-hand sides. */
+    public final List<Expr> targets;
+    /** Right-hand-side value to be assigned. */
+    public final Expr value;
+
+    /** AST for TARGETS[0] = TARGETS[1] = ... = VALUE spanning source locations [LEFT..RIGHT]. */
+    public AssignStmt(Location left, Location right, List<Expr> targets, Expr value) {
+        super(left, right);
+        this.targets = targets;
+        this.value = value;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/BinaryExpr.java

@@ -0,0 +1,31 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** <operand> <operator> <operand>. */
+public class BinaryExpr extends Expr {
+
+    /** Left operand. */
+    public final Expr left;
+    /** Operator name. */
+    public final String operator;
+    /** Right operand. */
+    public final Expr right;
+
+    /**
+     * An AST for expressions of the form LEFTEXPR OP RIGHTEXPR from text in range
+     * [LEFTLOC..RIGHTLOC].
+     */
+    public BinaryExpr(
+            Location leftLoc, Location rightLoc, Expr leftExpr, String op, Expr rightExpr) {
+        super(leftLoc, rightLoc);
+        left = leftExpr;
+        operator = op;
+        right = rightExpr;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/BooleanLiteral.java

@@ -0,0 +1,21 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Literals True or False. */
+public final class BooleanLiteral extends Literal {
+
+    /** True iff I represent True. */
+    public final boolean value;
+
+    /** An AST for the token True or False at [LEFT..RIGHT], depending on VALUE. */
+    public BooleanLiteral(Location left, Location right, boolean value) {
+        super(left, right);
+        this.value = value;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/CallExpr.java

@@ -0,0 +1,26 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.List;
+
+/** A function call. */
+public class CallExpr extends Expr {
+
+    /** The called function. */
+    public final Identifier function;
+    /** The actual parameter expressions. */
+    public final List<Expr> args;
+
+    /** AST for FUNCTION(ARGS) at [LEFT..RIGHT]. */
+    public CallExpr(Location left, Location right, Identifier function, List<Expr> args) {
+        super(left, right);
+        this.function = function;
+        this.args = args;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/ClassDef.java

@@ -0,0 +1,39 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.List;
+
+/** A class definition. */
+public class ClassDef extends Declaration {
+
+    /** Name of the declared class. */
+    public final Identifier name;
+    /** Name of the parent class. */
+    public final Identifier superClass;
+    /** Body of the class. */
+    public final List<Declaration> declarations;
+
+    /** An AST for class NAME(SUPERCLASS): DECLARATIONS. spanning source locations [LEFT..RIGHT]. */
+    public ClassDef(
+            Location left,
+            Location right,
+            Identifier name,
+            Identifier superClass,
+            List<Declaration> declarations) {
+        super(left, right);
+        this.name = name;
+        this.superClass = superClass;
+        this.declarations = declarations;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+
+    @Override
+    public Identifier getIdentifier() {
+        return this.name;
+    }
+}

src/main/java/chocopy/common/astnodes/ClassType.java

@@ -0,0 +1,21 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** A simple class type name. */
+public final class ClassType extends TypeAnnotation {
+
+    /** The denotation of the class in source. */
+    public final String className;
+
+    /** An AST denoting a type named CLASSNAME0 at [LEFT..RIGHT]. */
+    public ClassType(Location left, Location right, String className0) {
+        super(left, right);
+        className = className0;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/CompilerError.java

@@ -0,0 +1,56 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+/** Represents a single error. Does not correspond to any Python source construct. */
+public class CompilerError extends Node {
+
+    /**
+     * Represents an error with message MESSAGE. Iff SYNTAX, it is a syntactic error. The error
+     * applies to source text at [LEFT..RIGHT].
+     */
+    public CompilerError(Location left, Location right, String message, boolean syntax) {
+        super(left, right);
+        this.message = message;
+        this.syntax = syntax;
+    }
+
+    @JsonInclude(JsonInclude.Include.NON_DEFAULT)
+    public boolean isSyntax() {
+        return syntax;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        CompilerError that = (CompilerError) o;
+        return Objects.equals(message, that.message)
+                && Arrays.equals(getLocation(), that.getLocation());
+    }
+
+    @Override
+    public int hashCode() {
+        int result = Objects.hash(message);
+        result = 31 * result + Arrays.hashCode(getLocation());
+        return result;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+
+    /** The error message. */
+    public final String message;
+    /** True if this is a syntax error. */
+    private final boolean syntax;
+}

src/main/java/chocopy/common/astnodes/Declaration.java

@@ -0,0 +1,17 @@
+package chocopy.common.astnodes;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Base of all AST nodes representing definitions or declarations. */
+public abstract class Declaration extends Node {
+
+    /** A definition or declaration spanning source locations [LEFT..RIGHT]. */
+    public Declaration(Location left, Location right) {
+        super(left, right);
+    }
+
+    /** Return the identifier defined by this Declaration. */
+    @JsonIgnore
+    public abstract Identifier getIdentifier();
+}

src/main/java/chocopy/common/astnodes/Errors.java

@@ -0,0 +1,71 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.List;
+
+/** Collects the error messages in a Program. There is exactly one per Program node. */
+public class Errors extends Node {
+
+    /** The accumulated error messages in the order added. */
+    public final List<CompilerError> errors;
+
+    /** True iff multiple semantic errors allowed on a node. */
+    @JsonIgnore private boolean allowMultipleErrors;
+
+    /**
+     * An Errors whose list of CompilerErrors is ERRORS. The list should be modified using this.add.
+     */
+    @JsonCreator
+    public Errors(List<CompilerError> errors) {
+        super(null, null);
+        this.errors = errors;
+        allowMultipleErrors = true;
+    }
+
+    /** Return true iff there are any errors. */
+    public boolean hasErrors() {
+        return !this.errors.isEmpty();
+    }
+
+    /** Prevent multiple semantic errors on the same node. */
+    public void suppressMultipleErrors() {
+        allowMultipleErrors = false;
+    }
+
+    /**
+     * Add a new semantic error message attributed to NODE, with message String.format(MESSAGEFORM,
+     * ARGS).
+     */
+    public void semError(Node node, String messageForm, Object... args) {
+        if (allowMultipleErrors || !node.hasError()) {
+            String msg = String.format(messageForm, args);
+            CompilerError err = new CompilerError(null, null, msg, false);
+            err.setLocation(node.getLocation());
+            add(err);
+            if (!node.hasError()) {
+                node.setErrorMsg(msg);
+            }
+        }
+    }
+
+    /**
+     * Add a new syntax error message attributed to the source text between LEFT and RIGHT, and with
+     * message String.format(MESSAGEFORM, ARGS).
+     */
+    public void syntaxError(Location left, Location right, String messageForm, Object... args) {
+        add(new CompilerError(left, right, String.format(messageForm, args), true));
+    }
+
+    /** Add ERR to the list of errors. */
+    public void add(CompilerError err) {
+        errors.add(err);
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/Expr.java

@@ -0,0 +1,43 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.types.Type;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/**
+ * Base of all AST nodes representing expressions.
+ *
+ * <p>There is nothing in this class, but there will be many AST node types that have fields that
+ * are *any expression*. For those cases, having a field of this type will encompass all types of
+ * expressions such as binary expressions and literals that subclass this class.
+ */
+public abstract class Expr extends Node {
+
+    /** A Python expression spanning source locations [LEFT..RIGHT]. */
+    public Expr(Location left, Location right) {
+        super(left, right);
+    }
+
+    /**
+     * The type of the value that this expression evaluates to.
+     *
+     * <p>This field is always <tt>null</tt> after the parsing stage, but is populated by the
+     * typechecker in the semantic analysis stage.
+     *
+     * <p>After typechecking this field may be <tt>null</tt> only for expressions that cannot be
+     * assigned a type. In particular, {@link NoneLiteral} expressions will not have a typed
+     * assigned to them.
+     */
+    @JsonInclude(JsonInclude.Include.NON_NULL)
+    private Type inferredType;
+
+    /** Set getInferredType() to TYPE, returning TYPE. */
+    public Type setInferredType(Type type) {
+        inferredType = type;
+        return type;
+    }
+
+    public Type getInferredType() {
+        return inferredType;
+    }
+}

src/main/java/chocopy/common/astnodes/ExprStmt.java

@@ -0,0 +1,21 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Statements consisting of expressions. */
+public final class ExprStmt extends Stmt {
+
+    /** The expression I evaluate. */
+    public final Expr expr;
+
+    /** The AST for EXPR spanning source locations [LEFT..RIGHT] in a statement context. */
+    public ExprStmt(Location left, Location right, Expr expr) {
+        super(left, right);
+        this.expr = expr;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/ForStmt.java

@@ -0,0 +1,29 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.List;
+
+/** For statements. */
+public class ForStmt extends Stmt {
+    /** Control variable. */
+    public final Identifier identifier;
+    /** Source of values of control statement. */
+    public final Expr iterable;
+    /** Repeated statements. */
+    public final List<Stmt> body;
+
+    /** The AST for for IDENTIFIER in ITERABLE: BODY spanning source locations [LEFT..RIGHT]. */
+    public ForStmt(
+            Location left, Location right, Identifier identifier, Expr iterable, List<Stmt> body) {
+        super(left, right);
+        this.identifier = identifier;
+        this.iterable = iterable;
+        this.body = body;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/FuncDef.java

@@ -0,0 +1,50 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.List;
+
+/** Def statements. */
+public class FuncDef extends Declaration {
+
+    /** Defined name. */
+    public final Identifier name;
+    /** Formal parameters. */
+    public final List<TypedVar> params;
+    /** Return type annotation. */
+    public final TypeAnnotation returnType;
+    /** Local-variable,inner-function, global, and nonlocal declarations. */
+    public final List<Declaration> declarations;
+    /** Other statements. */
+    public final List<Stmt> statements;
+
+    /**
+     * The AST for def NAME(PARAMS) -> RETURNTYPE: DECLARATIONS STATEMENTS spanning source locations
+     * [LEFT..RIGHT].
+     */
+    public FuncDef(
+            Location left,
+            Location right,
+            Identifier name,
+            List<TypedVar> params,
+            TypeAnnotation returnType,
+            List<Declaration> declarations,
+            List<Stmt> statements) {
+        super(left, right);
+        this.name = name;
+        this.params = params;
+        this.returnType = returnType;
+        this.declarations = declarations;
+        this.statements = statements;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+
+    @Override
+    public Identifier getIdentifier() {
+        return this.name;
+    }
+}

src/main/java/chocopy/common/astnodes/GlobalDecl.java

@@ -0,0 +1,26 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Declaration of global variable. */
+public class GlobalDecl extends Declaration {
+
+    /** The declared variable. */
+    public final Identifier variable;
+
+    /** The AST for the declaration global VARIABLE spanning source locations [LEFT..RIGHT]. */
+    public GlobalDecl(Location left, Location right, Identifier variable) {
+        super(left, right);
+        this.variable = variable;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+
+    @Override
+    public Identifier getIdentifier() {
+        return this.variable;
+    }
+}

src/main/java/chocopy/common/astnodes/Identifier.java

@@ -0,0 +1,24 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** A simple identifier. */
+public class Identifier extends Expr {
+
+    /** Text of the identifier. */
+    public final String name;
+
+    /**
+     * An AST for the variable, method, or parameter named NAME, spanning source locations
+     * [LEFT..RIGHT].
+     */
+    public Identifier(Location left, Location right, String name) {
+        super(left, right);
+        this.name = name;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/IfExpr.java

@@ -0,0 +1,26 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Conditional expressions. */
+public class IfExpr extends Expr {
+    /** Boolean condition. */
+    public final Expr condition;
+    /** True branch. */
+    public final Expr thenExpr;
+    /** False branch. */
+    public final Expr elseExpr;
+
+    /** The AST for THENEXPR if CONDITION else ELSEEXPR spanning source locations [LEFT..RIGHT]. */
+    public IfExpr(Location left, Location right, Expr condition, Expr thenExpr, Expr elseExpr) {
+        super(left, right);
+        this.condition = condition;
+        this.thenExpr = thenExpr;
+        this.elseExpr = elseExpr;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/IfStmt.java

@@ -0,0 +1,35 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.List;
+
+/** Conditional statement. */
+public class IfStmt extends Stmt {
+    /** Test condition. */
+    public final Expr condition;
+    /** "True" branch. */
+    public final List<Stmt> thenBody;
+    /** "False" branch. */
+    public final List<Stmt> elseBody;
+
+    /**
+     * The AST for if CONDITION: THENBODY else: ELSEBODY spanning source locations [LEFT..RIGHT].
+     */
+    public IfStmt(
+            Location left,
+            Location right,
+            Expr condition,
+            List<Stmt> thenBody,
+            List<Stmt> elseBody) {
+        super(left, right);
+        this.condition = condition;
+        this.thenBody = thenBody;
+        this.elseBody = elseBody;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/IndexExpr.java

@@ -0,0 +1,24 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** List-indexing expression. */
+public class IndexExpr extends Expr {
+
+    /** Indexed list. */
+    public final Expr list;
+    /** Expression for index value. */
+    public final Expr index;
+
+    /** The AST for LIST[INDEX]. spanning source locations [LEFT..RIGHT]. */
+    public IndexExpr(Location left, Location right, Expr list, Expr index) {
+        super(left, right);
+        this.list = list;
+        this.index = index;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/IntegerLiteral.java

@@ -0,0 +1,21 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Integer numerals. */
+public final class IntegerLiteral extends Literal {
+
+    /** Value denoted. */
+    public final int value;
+
+    /** The AST for the literal VALUE, spanning source locations [LEFT..RIGHT]. */
+    public IntegerLiteral(Location left, Location right, int value) {
+        super(left, right);
+        this.value = value;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/ListExpr.java

@@ -0,0 +1,23 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.List;
+
+/** List displays. */
+public final class ListExpr extends Expr {
+
+    /** List of element expressions. */
+    public final List<Expr> elements;
+
+    /** The AST for [ ELEMENTS ]. spanning source locations [LEFT..RIGHT]. */
+    public ListExpr(Location left, Location right, List<Expr> elements) {
+        super(left, right);
+        this.elements = elements;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/ListType.java

@@ -0,0 +1,21 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Type denotation for a list type. */
+public final class ListType extends TypeAnnotation {
+
+    /** The element of list element. */
+    public final TypeAnnotation elementType;
+
+    /** The AST for the type annotation [ ELEMENTTYPE ]. spanning source locations [LEFT..RIGHT]. */
+    public ListType(Location left, Location right, TypeAnnotation elementType) {
+        super(left, right);
+        this.elementType = elementType;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/Literal.java

@@ -0,0 +1,16 @@
+package chocopy.common.astnodes;
+
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/**
+ * Base of all the literal nodes.
+ *
+ * <p>There is nothing in this class, but it is useful to isolate expressions that are constant
+ * literals.
+ */
+public abstract class Literal extends Expr {
+    /** A literal spanning source locations [LEFT..RIGHT]. */
+    public Literal(Location left, Location right) {
+        super(left, right);
+    }
+}

src/main/java/chocopy/common/astnodes/MemberExpr.java

@@ -0,0 +1,24 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Attribute accessor. */
+public class MemberExpr extends Expr {
+
+    /** Object selected from. */
+    public final Expr object;
+    /** Name of attribute (instance variable or method). */
+    public final Identifier member;
+
+    /** The AST for OBJECT.MEMBER. spanning source locations [LEFT..RIGHT]. */
+    public MemberExpr(Location left, Location right, Expr object, Identifier member) {
+        super(left, right);
+        this.object = object;
+        this.member = member;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/MethodCallExpr.java

@@ -0,0 +1,26 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.List;
+
+/** Method calls. */
+public class MethodCallExpr extends Expr {
+
+    /** Expression for the bound method to be called. */
+    public final MemberExpr method;
+    /** Actual parameters. */
+    public final List<Expr> args;
+
+    /** The AST for METHOD(ARGS). spanning source locations [LEFT..RIGHT]. */
+    public MethodCallExpr(Location left, Location right, MemberExpr method, List<Expr> args) {
+        super(left, right);
+        this.method = method;
+        this.args = args;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/Node.java

@@ -0,0 +1,176 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.io.IOException;
+
+/**
+ * Root of the AST class hierarchy. Every node has a left and right location, indicating the start
+ * and end of the represented construct in the source text.
+ *
+ * <p>Every node can be marked with an error message, which serves two purposes: 1. It indicates
+ * that an error message has been issued for this Node, allowing tne program to reduce cascades of
+ * error messages. 2. It aids in debugging by making it convenient to see which Nodes have caused an
+ * error.
+ */
+@JsonTypeInfo(
+        use = JsonTypeInfo.Id.NAME,
+        include = JsonTypeInfo.As.EXISTING_PROPERTY,
+        property = "kind")
+/* List of all concrete subclasses of Node. */
+@JsonSubTypes({
+    @JsonSubTypes.Type(AssignStmt.class),
+    @JsonSubTypes.Type(BinaryExpr.class),
+    @JsonSubTypes.Type(BooleanLiteral.class),
+    @JsonSubTypes.Type(CallExpr.class),
+    @JsonSubTypes.Type(ClassDef.class),
+    @JsonSubTypes.Type(ClassType.class),
+    @JsonSubTypes.Type(CompilerError.class),
+    @JsonSubTypes.Type(Errors.class),
+    @JsonSubTypes.Type(ExprStmt.class),
+    @JsonSubTypes.Type(ForStmt.class),
+    @JsonSubTypes.Type(FuncDef.class),
+    @JsonSubTypes.Type(GlobalDecl.class),
+    @JsonSubTypes.Type(Identifier.class),
+    @JsonSubTypes.Type(IfExpr.class),
+    @JsonSubTypes.Type(IfStmt.class),
+    @JsonSubTypes.Type(IndexExpr.class),
+    @JsonSubTypes.Type(IntegerLiteral.class),
+    @JsonSubTypes.Type(ListExpr.class),
+    @JsonSubTypes.Type(ListType.class),
+    @JsonSubTypes.Type(MemberExpr.class),
+    @JsonSubTypes.Type(MethodCallExpr.class),
+    @JsonSubTypes.Type(NoneLiteral.class),
+    @JsonSubTypes.Type(NonLocalDecl.class),
+    @JsonSubTypes.Type(Program.class),
+    @JsonSubTypes.Type(ReturnStmt.class),
+    @JsonSubTypes.Type(StringLiteral.class),
+    @JsonSubTypes.Type(TypedVar.class),
+    @JsonSubTypes.Type(UnaryExpr.class),
+    @JsonSubTypes.Type(VarDef.class),
+    @JsonSubTypes.Type(WhileStmt.class),
+})
+public abstract class Node {
+
+    /** Node-type indicator for JSON form. */
+    public final String kind;
+
+    /**
+     * Source position information: 0: line number of start, 1: column number of start, 2: line
+     * number of end, 3: column number of end.
+     */
+    private final int[] location = new int[4];
+
+    /**
+     * First error message "blamed" on this Node. When non-null, indicates that an error has been
+     * found in this Node.
+     */
+    @JsonInclude(JsonInclude.Include.NON_EMPTY)
+    private String errorMsg;
+
+    /** A Node corresponding to source text between LEFT and RIGHT. */
+    public Node(Location left, Location right) {
+        if (left != null) {
+            location[0] = left.getLine();
+            location[1] = left.getColumn();
+        }
+        if (right != null) {
+            location[2] = right.getLine();
+            location[3] = right.getColumn();
+        }
+        this.kind = getClass().getSimpleName();
+        this.errorMsg = null;
+    }
+
+    /**
+     * Return my source location as { <first line>, <first column>, <last line>, <last column> }.
+     * Result should not be modified, and contents will change after setLocation().
+     */
+    public int[] getLocation() {
+        return location;
+    }
+
+    /** Copy LOCATION as getLocation(). */
+    public void setLocation(final int[] location) {
+        System.arraycopy(location, 0, this.location, 0, 4);
+    }
+
+    public String getErrorMsg() {
+        return errorMsg;
+    }
+
+    public void setErrorMsg(String msg) {
+        this.errorMsg = msg;
+    }
+
+    /** Return true iff I have been marked with an error message. */
+    @JsonIgnore
+    public boolean hasError() {
+        return this.errorMsg != null;
+    }
+
+    /**
+     * Invoke ANALYZER on me as a node of static type T. See the comment on NodeAnalyzer. Returns
+     * modified Node.
+     */
+    public abstract <T> T dispatch(NodeAnalyzer<T> analyzer);
+
+    /** Print out the AST in JSON format. */
+    @Override
+    public String toString() {
+        try {
+            return toJSON();
+        } catch (JsonProcessingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /** Return a serialization of this node in JSON format. */
+    public String toJSON() throws JsonProcessingException {
+        return mapper.writeValueAsString(this);
+    }
+
+    /** Mapper to-and-from serialized JSON. */
+    private static final ObjectMapper mapper = new ObjectMapper();
+
+    static {
+        mapper.enable(SerializationFeature.INDENT_OUTPUT);
+        mapper.registerModule(new ParameterNamesModule());
+    }
+
+    /** Returns a T from JSON, a JSON-serialized T value with class CLAS. */
+    public static <T> T fromJSON(String json, Class<T> clas) throws IOException {
+        return mapper.readValue(json, clas);
+    }
+
+    /**
+     * Returns the result of converting JSON, a JSon-serialization of a Node value, into the value
+     * it serializes.
+     */
+    public static Node fromJSON(String json) throws IOException {
+        return fromJSON(json, Node.class);
+    }
+
+    /**
+     * Returns the result of converting TREE to the value of type T that it represents, where CLAS
+     * reflects T.
+     */
+    public static <T> T fromJSON(JsonNode tree, Class<T> clas) throws IOException {
+        return mapper.treeToValue(tree, clas);
+    }
+
+    /** Returns the translation of serialized value SRC into the corresponding JSON tree. */
+    public static JsonNode readTree(String src) throws IOException {
+        return mapper.readTree(src);
+    }
+}

src/main/java/chocopy/common/astnodes/NonLocalDecl.java

@@ -0,0 +1,26 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Nonlocal declaration. */
+public class NonLocalDecl extends Declaration {
+
+    /** Name of identifier being declared. */
+    public final Identifier variable;
+
+    /** The AST for nonlocal VARIABLE spanning source locations [LEFT..RIGHT]. */
+    public NonLocalDecl(Location left, Location right, Identifier variable) {
+        super(left, right);
+        this.variable = variable;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+
+    @Override
+    public Identifier getIdentifier() {
+        return this.variable;
+    }
+}

src/main/java/chocopy/common/astnodes/NoneLiteral.java

@@ -0,0 +1,17 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** The expression 'None'. */
+public final class NoneLiteral extends Literal {
+
+    /** The AST for None, spanning source locations [LEFT..RIGHT]. */
+    public NoneLiteral(Location left, Location right) {
+        super(left, right);
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/Program.java

@@ -0,0 +1,56 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/** An entire Chocopy program. */
+public class Program extends Node {
+
+    /** Initial variable, class, and function declarations. */
+    public final List<Declaration> declarations;
+    /** Trailing statements. */
+    public final List<Stmt> statements;
+    /** Accumulated errors. */
+    public final Errors errors;
+
+    /**
+     * The AST for the program DECLARATIONS STATEMENTS spanning source locations [LEFT..RIGHT].
+     *
+     * <p>ERRORS is the container for all error messages applying to the program.
+     */
+    public Program(
+            Location left,
+            Location right,
+            List<Declaration> declarations,
+            List<Stmt> statements,
+            Errors errors) {
+        super(left, right);
+        this.declarations = declarations;
+        this.statements = statements;
+        if (errors == null) {
+            this.errors = new Errors(new ArrayList<>());
+        } else {
+            this.errors = errors;
+        }
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+
+    /** Returns true iff there is at least one error in the program. */
+    @JsonIgnore
+    public boolean hasErrors() {
+        return errors.hasErrors();
+    }
+
+    /** A convenience method returning the list of all CompilerErrors for this program. */
+    @JsonIgnore
+    public List<CompilerError> getErrorList() {
+        return errors.errors;
+    }
+}

src/main/java/chocopy/common/astnodes/ReturnStmt.java

@@ -0,0 +1,21 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Return from function. */
+public class ReturnStmt extends Stmt {
+
+    /** Returned value. */
+    public final Expr value;
+
+    /** The AST for return VALUE spanning source locations [LEFT..RIGHT]. */
+    public ReturnStmt(Location left, Location right, Expr value) {
+        super(left, right);
+        this.value = value;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/Stmt.java

@@ -0,0 +1,18 @@
+package chocopy.common.astnodes;
+
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/**
+ * Base of all AST nodes representing statements.
+ *
+ * <p>There is nothing in this class, but there will be some AST node types that have fields that
+ * are *any statement* or a list of statements. For those cases, having a field of this type will
+ * encompass all types of statements such as expression statements, if statements, while statements,
+ * etc.
+ */
+public abstract class Stmt extends Node {
+    /** A statement spanning source locations [LEFT..RIGHT]. */
+    public Stmt(Location left, Location right) {
+        super(left, right);
+    }
+}

src/main/java/chocopy/common/astnodes/StringLiteral.java

@@ -0,0 +1,21 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** String constants. */
+public final class StringLiteral extends Literal {
+
+    /** Contents of the literal, not including quotation marks. */
+    public final String value;
+
+    /** The AST for a string literal containing VALUE, spanning source locations [LEFT..RIGHT]. */
+    public StringLiteral(Location left, Location right, String value) {
+        super(left, right);
+        this.value = value;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/TypeAnnotation.java

@@ -0,0 +1,11 @@
+package chocopy.common.astnodes;
+
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** Base of all AST nodes representing type annotations (list or class types. */
+public abstract class TypeAnnotation extends Node {
+    /** An annotation spanning source locations [LEFT..RIGHT]. */
+    public TypeAnnotation(Location left, Location right) {
+        super(left, right);
+    }
+}

src/main/java/chocopy/common/astnodes/TypedVar.java

@@ -0,0 +1,24 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** An identifier with attached type annotation. */
+public class TypedVar extends Node {
+
+    /** The typed identifier. */
+    public final Identifier identifier;
+    /** The declared type. */
+    public final TypeAnnotation type;
+
+    /** The AST for IDENTIFIER : TYPE. spanning source locations [LEFT..RIGHT]. */
+    public TypedVar(Location left, Location right, Identifier identifier, TypeAnnotation type) {
+        super(left, right);
+        this.identifier = identifier;
+        this.type = type;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/UnaryExpr.java

@@ -0,0 +1,24 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** An expression applying a unary operator. */
+public class UnaryExpr extends Expr {
+
+    /** The text representation of the operator. */
+    public final String operator;
+    /** The operand to which it is applied. */
+    public final Expr operand;
+
+    /** The AST for OPERATOR OPERAND spanning source locations [LEFT..RIGHT]. */
+    public UnaryExpr(Location left, Location right, String operator, Expr operand) {
+        super(left, right);
+        this.operator = operator;
+        this.operand = operand;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}

src/main/java/chocopy/common/astnodes/VarDef.java

@@ -0,0 +1,32 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+/** A declaration of a variable (i.e., with type annotation). */
+public class VarDef extends Declaration {
+    /** The variable and its assigned type. */
+    public final TypedVar var;
+    /** The initial value assigned. */
+    public final Literal value;
+
+    /**
+     * The AST for VAR = VALUE where VAR has a type annotation, and spanning source locations
+     * [LEFT..RIGHT].
+     */
+    public VarDef(Location left, Location right, TypedVar var, Literal value) {
+        super(left, right);
+        this.var = var;
+        this.value = value;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+
+    /** The identifier defined by this declaration. */
+    @Override
+    public Identifier getIdentifier() {
+        return this.var.identifier;
+    }
+}

src/main/java/chocopy/common/astnodes/WhileStmt.java

@@ -0,0 +1,25 @@
+package chocopy.common.astnodes;
+
+import chocopy.common.analysis.NodeAnalyzer;
+import java_cup.runtime.ComplexSymbolFactory.Location;
+
+import java.util.List;
+
+/** Indefinite repetition construct. */
+public class WhileStmt extends Stmt {
+    /** Test for whether to continue. */
+    public final Expr condition;
+    /** Loop body. */
+    public final List<Stmt> body;
+
+    /** The AST for while CONDITION: BODY spanning source locations [LEFT..RIGHT]. */
+    public WhileStmt(Location left, Location right, Expr condition, List<Stmt> body) {
+        super(left, right);
+        this.condition = condition;
+        this.body = body;
+    }
+
+    public <T> T dispatch(NodeAnalyzer<T> analyzer) {
+        return analyzer.analyze(this);
+    }
+}