DynamicJava: Nested interfaces are always static. Fixed ambiguity error occurring when the same field is inherited from two different supertypes. Improved "ambiguous name" error messages.

dlsmith · dlsmith · commit f8e25255cc9b · 2009-09-25T21:04:44.000Z
git-svn-id: file:///tmp/test-svn/trunk@5085 fe72c1cf-3628-48e9-8b72-1c46755d3cff
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/ExpressionChecker.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/ExpressionChecker.java
@@ -401,11 +401,17 @@ else if (context.fieldExists(first.image(), ts)) {
             }
           }
         }
-        catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }
+        catch (AmbiguousNameException e) {
+          setErrorStrings(node, className);
+          throw new ExecutionError("ambiguous.name", node);
+        }
         catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }
         catch (UnmatchedLookupException e) {
           if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }
-          else { throw new ExecutionError("ambiguous.name", node); }
+          else {
+            setErrorStrings(node, className);
+            throw new ExecutionError("ambiguous.name", node);
+          }
         }
         
         // Append member names until a field is encountered (or until all names are used up)
@@ -427,7 +433,10 @@ else if (ts.containsClass(classType, memberName.image(), context.accessModule())
             catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }
             catch (UnmatchedLookupException e) {
               if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }
-              else { throw new ExecutionError("ambiguous.name", node); }
+              else {
+                setErrorStrings(node, memberName.image());
+                throw new ExecutionError("ambiguous.name", node);
+              }
             }
             // TODO: Improve error when memberName is a non-static class
           }
@@ -530,10 +539,16 @@ private DJClass resolveThis(Option<String> outerName, Node node) {
         addRuntimeCheck(node, result, ref.field().type());
         return setType(node, result);
       }
-      catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }
+      catch (AmbiguousNameException e) {
+        setErrorStrings(node, node.getFieldName());
+        throw new ExecutionError("ambiguous.name", node);
+      }
       catch (UnmatchedLookupException e) {
         if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }
-        else { throw new ExecutionError("ambiguous.name", node); }
+        else {
+          setErrorStrings(node, node.getFieldName());
+          throw new ExecutionError("ambiguous.name", node);
+        }
       }
     }
     
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/StatementChecker.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/StatementChecker.java
@@ -227,7 +227,10 @@ private Type checkTypeName(TypeName t) {
           }
           else { return context.importTopLevelClass(c); }
         }
-        catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }
+        catch (AmbiguousNameException e) {
+          setErrorStrings(node, node.getName());
+          throw new ExecutionError("ambiguous.name", node);
+        }
       }
       
     }
@@ -246,7 +249,10 @@ private ClassType resolveClassName(String name, Node node) {
           DJClass c = context.getTopLevelClass(topLevelName, ts);
           result = (c == null) ? null : ts.makeClassType(c);
         }
-        catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }
+        catch (AmbiguousNameException e) {
+          setErrorStrings(node, topLevelName);
+          throw new ExecutionError("ambiguous.name", node);
+        }
       }
       else {
         try { result = ts.lookupClass(result, piece, IterUtil.<Type>empty(), context.accessModule()); }
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/TypeNameChecker.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/TypeNameChecker.java
@@ -277,22 +277,32 @@ private class TypeNameVisitor extends AbstractVisitor<Type> implements Lambda<Ty
             }
           }
         }
-        catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }
+        catch (AmbiguousNameException e) {
+          setErrorStrings(node, name);
+          throw new ExecutionError("ambiguous.name", node);
+        }
         catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }
         catch (UnmatchedLookupException e) {
           if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }
-          else { throw new ExecutionError("ambiguous.name", node); }
+          else {
+            setErrorStrings(node, name);
+            throw new ExecutionError("ambiguous.name", node);
+          }
         }
       }
       while (ids.hasNext()) {
+        String nextId = ids.next().image();
         try {
-          ClassType memberType = ts.lookupClass(t, ids.next().image(), IterUtil.<Type>empty(), context.accessModule());
+          ClassType memberType = ts.lookupClass(t, nextId, IterUtil.<Type>empty(), context.accessModule());
           t = memberType;
         }
         catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }
         catch (UnmatchedLookupException e) {
           if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }
-          else { throw new ExecutionError("ambiguous.name", node); }
+          else {
+            setErrorStrings(node, nextId);
+            throw new ExecutionError("ambiguous.name", node);
+          }
         }
       }
       
@@ -336,24 +346,34 @@ private class TypeNameVisitor extends AbstractVisitor<Type> implements Lambda<Ty
             t = context.getTypeVariable(name, ts);
           }
         }
-        catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }
+        catch (AmbiguousNameException e) {
+          setErrorStrings(node, name);
+          throw new ExecutionError("ambiguous.name", node);
+        }
         catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }
         catch (UnmatchedLookupException e) {
           if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }
-          else { throw new ExecutionError("ambiguous.name", node); }
+          else {
+            setErrorStrings(node, name);
+            throw new ExecutionError("ambiguous.name", node);
+          }
         }
       }
       
       while (ids.hasNext()) {
+        String nextId = ids.next().image();
         try {
           Iterable<Type> targs = checkStructureForList(allTargs.next());
-          ClassType memberType = ts.lookupClass(t, ids.next().image(), targs, context.accessModule());
+          ClassType memberType = ts.lookupClass(t, nextId, targs, context.accessModule());
           t = memberType;
         }
         catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument", node); }
         catch (UnmatchedLookupException e) {
           if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }
-          else { throw new ExecutionError("ambiguous.name", node); }
+          else {
+            setErrorStrings(node, nextId);
+            throw new ExecutionError("ambiguous.name", node);
+          }
         }
       }
       
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/symbol/TreeClass.java b/dynamicjava/src/edu/rice/cs/dynamicjava/symbol/TreeClass.java
@@ -194,7 +194,7 @@ public String declaredName() {
   
   public boolean isStatic() {
     if (_declaring == null) { return false; }
-    else { return _declaring.isInterface() || _ast instanceof EnumDeclaration || _mods.isStatic(); }
+    else { return _declaring.isInterface() || isInterface() || _ast instanceof EnumDeclaration || _mods.isStatic(); }
   }
   public boolean isAbstract() { return _mods.isAbstract(); }
   public boolean isFinal() { return _mods.isFinal(); }
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/symbol/TypeSystem.java b/dynamicjava/src/edu/rice/cs/dynamicjava/symbol/TypeSystem.java
@@ -8,6 +8,7 @@
 import edu.rice.cs.plt.iter.IterUtil;
 import edu.rice.cs.plt.lambda.Thunk;
 import edu.rice.cs.plt.lambda.Lambda;
+import edu.rice.cs.plt.object.ObjectUtil;
 
 import java.io.Serializable;
 
@@ -560,6 +561,18 @@ protected FieldReference(DJField field, Type type) {
     
     /** @return  The return type of the access (before capture) */
     public Type type() { return _type; }
+    
+    public boolean equals(Object that) {
+      if (this == that) { return true; }
+      else if (!(that instanceof FieldReference)) { return false; }
+      else {
+        FieldReference r = (FieldReference) that;
+        return _field.equals(r._field) && _type.equals(r._type);
+      }
+    }
+    
+    public int hashCode() { return ObjectUtil.hash(FieldReference.class, _field, _type); }
+    
   }
   
   
diff --git a/dynamicjava/src/koala/dynamicjava/interpreter/error/ExecutionError.java b/dynamicjava/src/koala/dynamicjava/interpreter/error/ExecutionError.java
@@ -83,6 +83,7 @@ public class ExecutionError extends Error {
   public ExecutionError(String s, Node n) {
     rawMessage = s;
     node       = n;
+    getMessage(); // ensure that s is valid while we have a useful stack trace
   }
   
   public ExecutionError(Throwable thrown) {
diff --git a/dynamicjava/src/koala/dynamicjava/interpreter/resources/messages.properties b/dynamicjava/src/koala/dynamicjava/interpreter/resources/messages.properties
@@ -144,7 +144,7 @@ No constructor in %0 matches this invocation\n\
 \    Expected return type: %4\n\
 \    Candidate signatures: %5
 
-ambiguous.name             = Name is ambiguous
+ambiguous.name             = The name '%0' is ambiguous
 ambiguous.inner.class      = Multiple classes in %0 have name '%1'
 ambiguous.field            = Multiple fields in %0 have name '%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 += (n < strings.length) ? strings[n] : "%"+n;
+            result += strings[n];
           }
         } else {
           result += c;

Original file line number	Diff line number	Diff line change
`@@ -401,11 +401,17 @@ else if (context.fieldExists(first.image(), ts)) {`
`401`	`401`	`}`
`402`	`402`	`}`
`403`	`403`	`}`
`404`		`- catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }`
	`404`	`+ catch (AmbiguousNameException e) {`
	`405`	`+ setErrorStrings(node, className);`
	`406`	`+ throw new ExecutionError("ambiguous.name", node);`
	`407`	`+ }`
`405`	`408`	`catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }`
`406`	`409`	`catch (UnmatchedLookupException e) {`
`407`	`410`	`if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }`
`408`		`- else { throw new ExecutionError("ambiguous.name", node); }`
	`411`	`+ else {`
	`412`	`+ setErrorStrings(node, className);`
	`413`	`+ throw new ExecutionError("ambiguous.name", node);`
	`414`	`+ }`
`409`	`415`	`}`
`410`	`416`
`411`	`417`	`// Append member names until a field is encountered (or until all names are used up)`
`@@ -427,7 +433,10 @@ else if (ts.containsClass(classType, memberName.image(), context.accessModule())`
`427`	`433`	`catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }`
`428`	`434`	`catch (UnmatchedLookupException e) {`
`429`	`435`	`if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }`
`430`		`- else { throw new ExecutionError("ambiguous.name", node); }`
	`436`	`+ else {`
	`437`	`+ setErrorStrings(node, memberName.image());`
	`438`	`+ throw new ExecutionError("ambiguous.name", node);`
	`439`	`+ }`
`431`	`440`	`}`
`432`	`441`	`// TODO: Improve error when memberName is a non-static class`
`433`	`442`	`}`
`@@ -530,10 +539,16 @@ private DJClass resolveThis(Option<String> outerName, Node node) {`
`530`	`539`	`addRuntimeCheck(node, result, ref.field().type());`
`531`	`540`	`return setType(node, result);`
`532`	`541`	`}`
`533`		`- catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }`
	`542`	`+ catch (AmbiguousNameException e) {`
	`543`	`+ setErrorStrings(node, node.getFieldName());`
	`544`	`+ throw new ExecutionError("ambiguous.name", node);`
	`545`	`+ }`
`534`	`546`	`catch (UnmatchedLookupException e) {`
`535`	`547`	`if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }`
`536`		`- else { throw new ExecutionError("ambiguous.name", node); }`
	`548`	`+ else {`
	`549`	`+ setErrorStrings(node, node.getFieldName());`
	`550`	`+ throw new ExecutionError("ambiguous.name", node);`
	`551`	`+ }`
`537`	`552`	`}`
`538`	`553`	`}`
`539`	`554`
Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,10 @@ private Type checkTypeName(TypeName t) {`
`227`	`227`	`}`
`228`	`228`	`else { return context.importTopLevelClass(c); }`
`229`	`229`	`}`
`230`		`- catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }`
	`230`	`+ catch (AmbiguousNameException e) {`
	`231`	`+ setErrorStrings(node, node.getName());`
	`232`	`+ throw new ExecutionError("ambiguous.name", node);`
	`233`	`+ }`
`231`	`234`	`}`
`232`	`235`
`233`	`236`	`}`
`@@ -246,7 +249,10 @@ private ClassType resolveClassName(String name, Node node) {`
`246`	`249`	`DJClass c = context.getTopLevelClass(topLevelName, ts);`
`247`	`250`	`result = (c == null) ? null : ts.makeClassType(c);`
`248`	`251`	`}`
`249`		`- catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }`
	`252`	`+ catch (AmbiguousNameException e) {`
	`253`	`+ setErrorStrings(node, topLevelName);`
	`254`	`+ throw new ExecutionError("ambiguous.name", node);`
	`255`	`+ }`
`250`	`256`	`}`
`251`	`257`	`else {`
`252`	`258`	`try { result = ts.lookupClass(result, piece, IterUtil.<Type>empty(), context.accessModule()); }`
Original file line number	Diff line number	Diff line change
`@@ -277,22 +277,32 @@ private class TypeNameVisitor extends AbstractVisitor<Type> implements Lambda<Ty`
`277`	`277`	`}`
`278`	`278`	`}`
`279`	`279`	`}`
`280`		`- catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }`
	`280`	`+ catch (AmbiguousNameException e) {`
	`281`	`+ setErrorStrings(node, name);`
	`282`	`+ throw new ExecutionError("ambiguous.name", node);`
	`283`	`+ }`
`281`	`284`	`catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }`
`282`	`285`	`catch (UnmatchedLookupException e) {`
`283`	`286`	`if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }`
`284`		`- else { throw new ExecutionError("ambiguous.name", node); }`
	`287`	`+ else {`
	`288`	`+ setErrorStrings(node, name);`
	`289`	`+ throw new ExecutionError("ambiguous.name", node);`
	`290`	`+ }`
`285`	`291`	`}`
`286`	`292`	`}`
`287`	`293`	`while (ids.hasNext()) {`
	`294`	`+ String nextId = ids.next().image();`
`288`	`295`	`try {`
`289`		`- ClassType memberType = ts.lookupClass(t, ids.next().image(), IterUtil.<Type>empty(), context.accessModule());`
	`296`	`+ ClassType memberType = ts.lookupClass(t, nextId, IterUtil.<Type>empty(), context.accessModule());`
`290`	`297`	`t = memberType;`
`291`	`298`	`}`
`292`	`299`	`catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }`
`293`	`300`	`catch (UnmatchedLookupException e) {`
`294`	`301`	`if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }`
`295`		`- else { throw new ExecutionError("ambiguous.name", node); }`
	`302`	`+ else {`
	`303`	`+ setErrorStrings(node, nextId);`
	`304`	`+ throw new ExecutionError("ambiguous.name", node);`
	`305`	`+ }`
`296`	`306`	`}`
`297`	`307`	`}`
`298`	`308`
`@@ -336,24 +346,34 @@ private class TypeNameVisitor extends AbstractVisitor<Type> implements Lambda<Ty`
`336`	`346`	`t = context.getTypeVariable(name, ts);`
`337`	`347`	`}`
`338`	`348`	`}`
`339`		`- catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }`
	`349`	`+ catch (AmbiguousNameException e) {`
	`350`	`+ setErrorStrings(node, name);`
	`351`	`+ throw new ExecutionError("ambiguous.name", node);`
	`352`	`+ }`
`340`	`353`	`catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }`
`341`	`354`	`catch (UnmatchedLookupException e) {`
`342`	`355`	`if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }`
`343`		`- else { throw new ExecutionError("ambiguous.name", node); }`
	`356`	`+ else {`
	`357`	`+ setErrorStrings(node, name);`
	`358`	`+ throw new ExecutionError("ambiguous.name", node);`
	`359`	`+ }`
`344`	`360`	`}`
`345`	`361`	`}`
`346`	`362`
`347`	`363`	`while (ids.hasNext()) {`
	`364`	`+ String nextId = ids.next().image();`
`348`	`365`	`try {`
`349`	`366`	`Iterable<Type> targs = checkStructureForList(allTargs.next());`
`350`		`- ClassType memberType = ts.lookupClass(t, ids.next().image(), targs, context.accessModule());`
	`367`	`+ ClassType memberType = ts.lookupClass(t, nextId, targs, context.accessModule());`
`351`	`368`	`t = memberType;`
`352`	`369`	`}`
`353`	`370`	`catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument", node); }`
`354`	`371`	`catch (UnmatchedLookupException e) {`
`355`	`372`	`if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }`
`356`		`- else { throw new ExecutionError("ambiguous.name", node); }`
	`373`	`+ else {`
	`374`	`+ setErrorStrings(node, nextId);`
	`375`	`+ throw new ExecutionError("ambiguous.name", node);`
	`376`	`+ }`
`357`	`377`	`}`
`358`	`378`	`}`
`359`	`379`
Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,7 @@ public String declaredName() {`
`194`	`194`
`195`	`195`	`public boolean isStatic() {`
`196`	`196`	`if (_declaring == null) { return false; }`
`197`		`- else { return _declaring.isInterface() \|\| _ast instanceof EnumDeclaration \|\| _mods.isStatic(); }`
	`197`	`+ else { return _declaring.isInterface() \|\| isInterface() \|\| _ast instanceof EnumDeclaration \|\| _mods.isStatic(); }`
`198`	`198`	`}`
`199`	`199`	`public boolean isAbstract() { return _mods.isAbstract(); }`
`200`	`200`	`public boolean isFinal() { return _mods.isFinal(); }`
Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,7 @@ public class ExecutionError extends Error {`
`83`	`83`	`public ExecutionError(String s, Node n) {`
`84`	`84`	`rawMessage = s;`
`85`	`85`	`node = n;`
	`86`	`+ getMessage(); // ensure that s is valid while we have a useful stack trace`
`86`	`87`	`}`
`87`	`88`
`88`	`89`	`public ExecutionError(Throwable thrown) {`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ public String getMessage(String key, String[] strings) {`
`85`	`85`	`numb += c;`
`86`	`86`	`} while (++i < rawMessage.length());`
`87`	`87`	`int n = Integer.parseInt(numb);`
`88`		`- result += (n < strings.length) ? strings[n] : "%"+n;`
	`88`	`+ result += strings[n];`
`89`	`89`	`}`
`90`	`90`	`} else {`
`91`	`91`	`result += c;`