DynamicJava: fixed broken final variable mutation check (was allowing some incorrect code and rejecting good code) internal failures when constructing error messages are more cleanly handled

dlsmith · dlsmith · commit eef32107e75e · 2009-09-24T17:10:50.000Z
git-svn-id: file:///tmp/test-svn/trunk@5080 fe72c1cf-3628-48e9-8b72-1c46755d3cff
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/DynamicJava.java b/dynamicjava/src/edu/rice/cs/dynamicjava/DynamicJava.java
@@ -33,7 +33,7 @@ public static void main(String... args) throws IOException {
         catch (InterpreterException e) { e.printUserMessage(); debug.log(e); }
         catch (RuntimeException e) {
           System.out.println("INTERNAL ERROR: Uncaught exception");
-          e.printStackTrace();
+          e.printStackTrace(System.out);
         }
         System.out.println();
       }
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/BaseContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/BaseContext.java
@@ -37,6 +37,7 @@ public Iterable<LocalFunction> getLocalFunctions(String name, TypeSystem ts, Ite
   public TypeContext importStaticMembers(DJClass c) { throw new UnsupportedOperationException(); }
   public TypeContext importTopLevelClass(DJClass c) { throw new UnsupportedOperationException(); }
   public TypeContext importTopLevelClasses(String pkg) { throw new UnsupportedOperationException(); }
+  public boolean inConstructorBody() { return false; }
   public boolean localFunctionExists(String name, TypeSystem ts) { return false; }
   public boolean localVariableExists(String name, TypeSystem ts) { return false; }
   public String makeAnonymousClassName() { throw new UnsupportedOperationException(); }
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/ClassChecker.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/ClassChecker.java
@@ -263,8 +263,8 @@ else if (!mods.isAbstract() && node.getBody() == null) {
     @Override public Void visit(ConstructorDeclaration node) {
       DJConstructor k = getConstructor(node);
       if (_c.isAnonymous() || !_c.declaredName().equals(node.getName())) {
-        setErrorStrings(node, SymbolUtil.shortName(_c));
-        throw new ExecutionError("constructor.name");
+        setErrorStrings(node, node.getName());
+        throw new ExecutionError("constructor.name", node);
       }
       
       TypeContext sigContext = new FunctionSignatureContext(_bodyContext, k);
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/ClassContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/ClassContext.java
@@ -141,6 +141,8 @@ private boolean hasMethod(String name, TypeSystem ts) {
     else { return super.getThis(expected, ts); }
   }
   
+  @Override public boolean inConstructorBody() { return false; }
+  
   /**
    * The expected type of a {@code return} statement in the given context, or {@code null}
    * if {@code return} statements should not appear here.
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/DelegatingContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/DelegatingContext.java
@@ -210,6 +210,8 @@ public DJClass getThis(String className) {
   
   public DJClass getThis(Type expected, TypeSystem ts) { return _next.getThis(expected, ts); }
   
+  public boolean inConstructorBody() { return _next.inConstructorBody(); }
+  
   /**
    * The expected type of a {@code return} statement in the given context, or {@code null}
    * if {@code return} statements should not appear here.
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/ExpressionChecker.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/ExpressionChecker.java
@@ -343,10 +343,12 @@ private class ExpressionVisitor extends AbstractVisitor<Type> implements Lambda<
         Expression resolvedExp = (Expression) resolved;
         resolvedExp.acceptVisitor(this);
         setTranslation(node, resolvedExp);
-        // VARIABLE_TYPE and TYPE properties are important in the enclosing context; others
-        // (such as FIELD) are not, and need not be copied to the AmbiguousName
+        // VARIABLE_TYPE, TYPE, FIELD, and VARIABLE properties are important in the enclosing context;
+        // others are not, and need not be copied to the AmbiguousName
         if (hasVariableType(resolvedExp)) { setVariableType(node, getVariableType(resolvedExp)); }
         if (hasValue(resolvedExp)) { setValue(node, getValue(resolvedExp)); }
+        if (hasField(resolvedExp)) { setField(node, getField(resolvedExp)); }
+        if (hasVariable(resolvedExp)) { setVariable(node, getVariable(resolvedExp)); }
         return setType(node, getType(resolvedExp));
       }
     }
@@ -1654,9 +1656,15 @@ private Type handleBooleanExpression(BinaryExpression node) {
       if (!hasVariableType(left)) {
         throw new ExecutionError("left.expression", node);
       }
-      if (hasVariable(left) && getVariable(left).isFinal() ||
-          hasField(left) && getField(left).isFinal()) {
-        throw new ExecutionError("cannot.modify", node);
+      if (!context.inConstructorBody()) {
+        if (hasVariable(left) && getVariable(left).isFinal()) {
+          setErrorStrings(node, getVariable(left).declaredName());
+          throw new ExecutionError("cannot.modify", node);
+        }
+        else if (hasField(left) && getField(left).isFinal()) {
+          setErrorStrings(node, getField(left).declaredName());
+          throw new ExecutionError("cannot.modify", node);
+        }
       }
       
       Type target = getVariableType(left);
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/FunctionContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/FunctionContext.java
@@ -84,6 +84,8 @@ private boolean isLocalFunction(String name) {
     else { return super.getThis(expected, ts); }
   }
   
+  @Override public boolean inConstructorBody() { return _f instanceof DJConstructor; }
+  
   @Override public Type getReturnType() {
     if (_f instanceof LocalFunction) { return ((LocalFunction) _f).returnType(); }
     else if (_f instanceof DJMethod) { return ((DJMethod) _f).returnType(); }
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/StatementChecker.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/StatementChecker.java
@@ -253,7 +253,7 @@ private ClassType resolveClassName(String name, Node node) {
         catch (InvalidTypeArgumentException e) { throw new RuntimeException("can't create raw type"); }
         catch (UnmatchedLookupException e) {
           setErrorStrings(node, piece);
-          if (e.matches() > 1) { throw new ExecutionError("ambiguous.inner.class"); }
+          if (e.matches() > 1) { throw new ExecutionError("ambiguous.inner.class", node); }
           else { throw new ExecutionError("no.such.inner.class", node); }
         }
       }
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/TopLevelContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/TopLevelContext.java
@@ -349,6 +349,8 @@ protected TypeContext duplicate(TypeContext next) {
   
   @Override public DJClass getThis(Type expected, TypeSystem ts) { return null; }
   
+  @Override public boolean inConstructorBody() { return false; }
+  
   /**
    * The expected type of a {@code return} statement in the given context, or {@code null}
    * if {@code return} statements should not appear here.
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/TypeContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/TypeContext.java
@@ -141,6 +141,9 @@ public interface TypeContext {
    */
   public DJClass getThis(Type expected, TypeSystem ts);
   
+  /** Whether this is immediately within a constructor body. */
+  public boolean inConstructorBody();
+  
   /**
    * The expected type of a {@code return} statement in the given context, or {@code null}
    * if {@code return} statements should not appear here.
diff --git a/dynamicjava/src/koala/dynamicjava/interpreter/error/ExecutionError.java b/dynamicjava/src/koala/dynamicjava/interpreter/error/ExecutionError.java
@@ -74,22 +74,6 @@ public class ExecutionError extends Error {
    */
   private String rawMessage;
   
-  /**
-   * Constructs an <code>ExecutionError</code> with no detail message. 
-   */
-  public ExecutionError() {
-    this("");
-  }
-  
-  /**
-   * Constructs an <code>ExecutionError</code> with the specified 
-   * detail message. 
-   * @param s the detail message (a key in a resource file).
-   */
-  public ExecutionError(String s) {
-    this(s, null);
-  }
-  
   /**
    * Constructs an <code>ExecutionError</code> with the specified 
    * detail message, filename, line and column. 
@@ -154,10 +138,8 @@ public void printStackTrace(PrintWriter w) {
    * Returns the error message string of this exception
    */
   public String getMessage() {
-    return reader.getMessage(rawMessage,
-                             node != null &&
-                             node.hasProperty(NodeProperties.ERROR_STRINGS)
-                               ? (String[])node.getProperty(NodeProperties.ERROR_STRINGS)
-                               : null);
+    String [] args = new String[0];
+    if (node != null && NodeProperties.hasErrorStrings(node)) { args = NodeProperties.getErrorStrings(node); }
+    return reader.getMessage(rawMessage, args);
   }
 }
diff --git a/dynamicjava/src/koala/dynamicjava/interpreter/error/ThrownException.java b/dynamicjava/src/koala/dynamicjava/interpreter/error/ThrownException.java
diff --git a/dynamicjava/src/koala/dynamicjava/interpreter/resources/messages.properties b/dynamicjava/src/koala/dynamicjava/interpreter/resources/messages.properties
@@ -186,7 +186,7 @@ bitwise.expression.type    = Bad type in bitwise expression
 boolean.expression.type    = Bad type in boolean expression
 
 # Used by EvaluationVisitor
-cannot.modify              = This variable cannot be modified
+cannot.modify              = Variable '%0' cannot be modified
 
 # Used by CompleteTypeSystem
 cast.types                 = Bad types in cast: from %0 to %1
diff --git a/dynamicjava/src/koala/dynamicjava/util/LocalizedMessageReader.java b/dynamicjava/src/koala/dynamicjava/util/LocalizedMessageReader.java
@@ -85,7 +85,7 @@ public String getMessage(String key, String[] strings) {
               numb += c;
             } while (++i < rawMessage.length());
             int n = Integer.parseInt(numb);
-            result += strings[n];
+            result += (n < strings.length) ? strings[n] : "%"+n;
           }
         } else {
           result += c;

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public static void main(String... args) throws IOException {`
`33`	`33`	`catch (InterpreterException e) { e.printUserMessage(); debug.log(e); }`
`34`	`34`	`catch (RuntimeException e) {`
`35`	`35`	`System.out.println("INTERNAL ERROR: Uncaught exception");`
`36`		`- e.printStackTrace();`
	`36`	`+ e.printStackTrace(System.out);`
`37`	`37`	`}`
`38`	`38`	`System.out.println();`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -141,6 +141,8 @@ private boolean hasMethod(String name, TypeSystem ts) {`
`141`	`141`	`else { return super.getThis(expected, ts); }`
`142`	`142`	`}`
`143`	`143`
	`144`	`+ @Override public boolean inConstructorBody() { return false; }`
	`145`	`+`
`144`	`146`	`/**`
`145`	`147`	`* The expected type of a {@code return} statement in the given context, or {@code null}`
`146`	`148`	`* if {@code return} statements should not appear here.`
Original file line number	Diff line number	Diff line change
`@@ -84,6 +84,8 @@ private boolean isLocalFunction(String name) {`
`84`	`84`	`else { return super.getThis(expected, ts); }`
`85`	`85`	`}`
`86`	`86`
	`87`	`+ @Override public boolean inConstructorBody() { return _f instanceof DJConstructor; }`
	`88`	`+`
`87`	`89`	`@Override public Type getReturnType() {`
`88`	`90`	`if (_f instanceof LocalFunction) { return ((LocalFunction) _f).returnType(); }`
`89`	`91`	`else if (_f instanceof DJMethod) { return ((DJMethod) _f).returnType(); }`
Original file line number	Diff line number	Diff line change
`@@ -253,7 +253,7 @@ private ClassType resolveClassName(String name, Node node) {`
`253`	`253`	`catch (InvalidTypeArgumentException e) { throw new RuntimeException("can't create raw type"); }`
`254`	`254`	`catch (UnmatchedLookupException e) {`
`255`	`255`	`setErrorStrings(node, piece);`
`256`		`- if (e.matches() > 1) { throw new ExecutionError("ambiguous.inner.class"); }`
	`256`	`+ if (e.matches() > 1) { throw new ExecutionError("ambiguous.inner.class", node); }`
`257`	`257`	`else { throw new ExecutionError("no.such.inner.class", node); }`
`258`	`258`	`}`
`259`	`259`	`}`