From 84b1c679b9b0eaaa97aa36332bfa88331a17e82d Mon Sep 17 00:00:00 2001 From: Apoorva Ranade Date: Sat, 13 Mar 2021 16:03:23 +0530 Subject: [PATCH] Progress on class def node analyzer --- .../common/analysis/types/ClassVType.java | 4 +- .../java/chocopy/pa2/DeclarationAnalyzer.java | 135 +++++++++++++++--- 2 files changed, 116 insertions(+), 23 deletions(-) diff --git a/src/main/java/chocopy/common/analysis/types/ClassVType.java b/src/main/java/chocopy/common/analysis/types/ClassVType.java index 42a312f..af04de7 100644 --- a/src/main/java/chocopy/common/analysis/types/ClassVType.java +++ b/src/main/java/chocopy/common/analysis/types/ClassVType.java @@ -12,9 +12,9 @@ import java.util.Objects; public class ClassVType extends ValueType { /** The name of the class. */ - private final String className; + public final String className; public SymbolTable scope; - public Identifier super_class; + public ClassVType super_class; /** A class type for the class named CLASSNAME. */ @JsonCreator public ClassVType(@JsonProperty String className) { diff --git a/src/main/java/chocopy/pa2/DeclarationAnalyzer.java b/src/main/java/chocopy/pa2/DeclarationAnalyzer.java index 33bfe91..d2e5fc3 100644 --- a/src/main/java/chocopy/pa2/DeclarationAnalyzer.java +++ b/src/main/java/chocopy/pa2/DeclarationAnalyzer.java @@ -4,7 +4,7 @@ import chocopy.common.analysis.AbstractNodeAnalyzer; import chocopy.common.analysis.SymbolTable; import chocopy.common.analysis.types.*; import chocopy.common.astnodes.*; - +import java.util.*; /** Analyzes declarations to create a top-level symbol table. */ public class DeclarationAnalyzer extends AbstractNodeAnalyzer { @@ -15,7 +15,7 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer private final SymbolTable globals = sym; /** Receiver for semantic error messages. */ private final Errors errors; - + private ClassVType current_class=null; /** A new declaration analyzer sending errors to ERRORS0. */ public DeclarationAnalyzer(Errors errors0) { @@ -23,18 +23,30 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer ClassVType cvt = new ClassVType("object"); FuncValueType init = new FuncValueType(Type.OBJECT_TYPE); init.parameters.add(Type.OBJECT_TYPE); + SymbolTable cvt_scope=new SymbolTable<>(sym); + cvt_scope.put("init",init); + cvt.scope=cvt_scope; sym.put("object", cvt); cvt = new ClassVType("int"); init = new FuncValueType(Type.INT_TYPE); init.parameters.add(Type.INT_TYPE); + cvt_scope=new SymbolTable<>(sym); + cvt_scope.put("init",init); + cvt.scope=cvt_scope; sym.put("int", cvt); cvt = new ClassVType("str"); init = new FuncValueType(Type.STR_TYPE); init.parameters.add(Type.STR_TYPE); + cvt_scope=new SymbolTable<>(sym); + cvt_scope.put("init",init); + cvt.scope=cvt_scope; sym.put("str", cvt); cvt = new ClassVType("bool"); init = new FuncValueType(Type.BOOL_TYPE); init.parameters.add(Type.BOOL_TYPE); + cvt_scope=new SymbolTable<>(sym); + cvt_scope.put("init",init); + cvt.scope=cvt_scope; sym.put("bool", cvt); } @@ -61,7 +73,13 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer { errors.semError( id, "Duplicate declaration of identifier in same " + "scope: %s", name); - } + } + else if (sym.get(name)!= null && sym.get(name) instanceof ClassVType) + { + errors.semError( + id, "Cannot shadow class name: %s", name); + continue; + } else { sym.put(name, type); @@ -76,11 +94,6 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer } return null; } - - @Override - public Type analyze(VarDef varDef) { - return ValueType.annotationToValueType(varDef.var.type); - } @Override public Type analyze(FuncDef node) { FuncValueType current_func=new FuncValueType((ValueType) node.returnType.dispatch(this)); @@ -95,11 +108,10 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer node.name, "Duplicate declaration of identifier in same " + "scope: %s", param.identifier.name); continue; } - else if (sym.get(param.identifier.name)!= null && sym.get(param.identifier.name) instanceof ClassVType) + else if (sym.get(param.identifier.name)!= null && sym.get(param.identifier.name) instanceof ClassVType) { - System.out.println("Error:"+sym.get(param.identifier.name)); errors.semError( - node.name, "Parameter shadows class name: %s", param.identifier.name); + param.identifier, "Cannot shadow class name: %s", param.identifier.name); continue; } @@ -114,18 +126,29 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer String name = id.name; Type type = decl.dispatch(this); - - if (type == null) { + if (type == null) + { continue; } - if (sym.declares(name)) { + if (sym.declares(name)) + { errors.semError( id, "Duplicate declaration of identifier in same " + "scope: %s", name); - } else { + continue; + } + else if (sym.get(name)!= null && sym.get(name) instanceof ClassVType) + { + errors.semError(id, "Cannot shadow class name: %s", name); + continue; + } + else + { sym.put(name, type); } } + /*for(String s:sym.getDeclaredSymbols()) + System.out.println(" "+s);*/ sym = sym.getParent(); return current_func; } @@ -140,14 +163,27 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer } return globals.get(node.variable.name); } + public boolean compare_functions(FuncValueType fun1, FuncValueType fun2) { + if (fun1.returnType.equals(fun2.returnType)==false) + return false; + if (fun1.parameters.size() != fun2.parameters.size()) + return false; + for (int i=1; i(sym); + SymbolTable current_scope=new SymbolTable<>(sym); sym=current_scope; + current_class=cvt; Type super_class = sym.get(node.superClass.name); - cvt.super_class = node.superClass; + cvt.super_class = (ClassVType)super_class; + SymbolTable super_scope=null; + Set super_syms=null; if (super_class == null) { errors.semError( @@ -165,22 +201,79 @@ public class DeclarationAnalyzer extends AbstractNodeAnalyzer } else { + super_scope = cvt.super_class.scope; + super_syms = super_scope.getDeclaredSymbols(); for (Declaration decl : node.declarations) { Identifier id = decl.getIdentifier(); String name = id.name; Type type = decl.dispatch(this); - if (sym.declares(name)) { + + if (type == null) + continue; + + if (sym.declares(name)) + { errors.semError( id, "Duplicate declaration of identifier in same " + "scope: %s", name); } - else - { - sym.put(name, type); + if (type instanceof ClassVType || type instanceof ListValueType) + {//Check for attribute type + if (super_syms.contains(name)) + {//Check for redefined superclass attribute + errors.semError( + id, "Cannot re-define attribute: %s", name); + } + else + sym.put(name, type); } + else if(type instanceof FuncValueType) + {//For function declarations + List params = ((FuncValueType)type).parameters; + if(params.size() < 1 || (params.get(0) instanceof ClassVType==false) || ((ClassVType)params.get(0)).className.equals(current_class.className)==false) + errors.semError( + id, "First parameter of method must be of same class: %s", name); + if (super_syms.contains(name)) + { + if ((super_scope.get(id.name) instanceof FuncValueType)==false) + errors.semError(id, "Cannot re-define attribute: %s" + name); + else + { + FuncValueType super_func = (FuncValueType) super_scope.get(id.name); + FuncValueType current_func = (FuncValueType) type; + if (compare_functions(super_func, current_func)) + sym.put(name, type); + else + errors.semError( + id, "Method overridden with different type signature: %s" + name); + } + } + else + sym.put(name, type); + } } } + for (String super_sym : super_syms) + { + if (sym.getDeclaredSymbols().contains(super_sym)==false) + sym.put(super_sym, super_scope.get(super_sym)); + } sym = sym.getParent(); + current_class=null; return cvt; } + @Override + public Type analyze(VarDef node) + { + Type var_type = sym.get(node.var.identifier.name); + if (node.var.identifier.name!=current_class.className && var_type==null) + errors.semError( + node, "Cannot re-define attribute: %s", node.var.identifier.name); + return ValueType.annotationToValueType(node.var.type); + } + @Override + public Type analyze(ListType node) + { + return ValueType.annotationToValueType(node); + } }