DynamicJava: Implemented qualified super expressions (parsing and type checking). Fixed misc parser bugs. The parser (driven by SourceChecker) can now handle all of the drjava, dynamicjava, plt, and javalanglevels source files.

dlsmith · dlsmith · commit 75d6ee48e583 · 2009-03-19T22:02:02.000Z
git-svn-id: file:///tmp/test-svn/trunk@4829 fe72c1cf-3628-48e9-8b72-1c46755d3cff
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/BaseContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/BaseContext.java
@@ -25,7 +25,6 @@ public Iterable<LocalFunction> getLocalFunctions(String name, TypeSystem ts, Ite
   public LocalVariable getLocalVariable(String name, TypeSystem ts) { return null; }
   public String getPackage() { return ""; }
   public Type getReturnType() { return null; }
-  public Type getSuperType(TypeSystem ts) { return null; }
   public DJClass getThis() { return null; }
   public DJClass getThis(String className) { return null; }
   public DJClass getTopLevelClass(String name, TypeSystem ts) throws AmbiguousNameException { return null; }
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/ClassContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/ClassContext.java
@@ -142,10 +142,4 @@ private boolean hasMethod(String name, TypeSystem ts) {
    */
   @Override public Iterable<Type> getDeclaredThrownTypes() { return IterUtil.empty(); }
   
-  /**
-   * Return the type referenced by {@code super} in the current context, or {@code null}
-   * if there is no such type (for example, in a static context).
-   */
-  @Override public Type getSuperType(TypeSystem ts) { return _c.immediateSuperclass(); }
-  
 }
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/CompositeException.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/CompositeException.java
@@ -12,8 +12,13 @@ public class CompositeException extends InterpreterException {
   private final SizedIterable<InterpreterException> _exceptions;
   
   public CompositeException(Iterable<? extends InterpreterException> exceptions) {
+    super(extractCause(exceptions));
     _exceptions = IterUtil.snapshot(exceptions);
   }
+  
+  private static InterpreterException extractCause(Iterable<? extends InterpreterException> exceptions) {
+    return IterUtil.isEmpty(exceptions) ? null : IterUtil.first(exceptions);
+  }
 
   public void printUserMessage(PrintWriter out) {
     out.println(_exceptions.size() + " errors:");
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/DelegatingContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/DelegatingContext.java
@@ -208,14 +208,6 @@ public DJClass getThis(String className) {
     return _next.getThis(className);
   }
   
-  /**
-   * Return the type referenced by {@code super} in the current context, or {@code null}
-   * if there is no such type (for example, in a static context).
-   */
-  public Type getSuperType(TypeSystem ts) {
-    return _next.getSuperType(ts);
-  }
-  
   /**
    * 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
@@ -183,7 +183,7 @@ public void checkConstructorCall(ConstructorCall node) {
     Iterable<Type> targs = IterUtil.empty();
     
     Type type;
-    if (node.isSuper()) { type = context.getSuperType(ts); }
+    if (node.isSuper()) { type = context.getThis().immediateSuperclass(); }
     else { type = SymbolUtil.thisType(context.getThis()); }
     if (type == null) {
       throw new IllegalArgumentException("Can't check a ConstructorCall in this context");
@@ -373,24 +373,28 @@ else if (ts.containsClass(classType, memberName.image())) {
       else { return setType(node, SymbolUtil.typeOfPrimitiveClass(node.getType())); }
     }
     
-    /**
-     * Visits a ThisExpression
-     * @return  The type of this, according to the context.
-     */
-    @Override public Type visit(ThisExpression node) {
-      String name = node.getClassName();
-      DJClass thisC;
-      if (name.equals("")) {
-        thisC = context.getThis();
-        if (thisC == null) { throw new ExecutionError("this.undefined", node); }
+    private DJClass resolveThis(Option<String> outerName, Node node) {
+      DJClass result;
+      if (outerName.isNone()) {
+        result = context.getThis();
+        if (result == null) { throw new ExecutionError("this.undefined", node); }
       }
       else {
-        thisC = context.getThis(name);
-        if (thisC == null) {
-          setErrorStrings(node, name);
+        result = context.getThis(outerName.unwrap());
+        if (result == null) {
+          setErrorStrings(node, outerName.unwrap());
           throw new ExecutionError("undefined.class", node);
         }
       }
+      return result;
+    }
+    
+    /**
+     * Visits a ThisExpression
+     * @return  The type of this, according to the context.
+     */
+    @Override public Type visit(ThisExpression node) {
+      DJClass thisC = resolveThis(node.getClassName(), node);
       setDJClass(node, thisC);
       return setType(node, SymbolUtil.thisType(thisC));
     }
@@ -473,7 +477,8 @@ else if (ts.containsClass(classType, memberName.image())) {
      * @return  The type of the expression
      */
     @Override public Type visit(SuperFieldAccess node) {
-      Type t = context.getSuperType(ts);
+      DJClass c = resolveThis(node.getClassName(), node);
+      Type t = c.immediateSuperclass();
       if (t == null) {
         throw new ExecutionError("super.undefined", node);
       }
@@ -483,7 +488,7 @@ else if (ts.containsClass(classType, memberName.image())) {
         FieldReference ref = ts.lookupField(obj, node.getFieldName());
         // TODO: Check accessibility of field
         setField(node, ref.field());
-        setDJClass(node, context.getThis());
+        setDJClass(node, c);
         setVariableType(node, ref.type());
         Type result = ts.capture(ref.type());
         addRuntimeCheck(node, result, ref.field().type());
@@ -639,7 +644,8 @@ else if (ts.containsClass(classType, memberName.image())) {
      * @return The type of the expression
      */
     @Override public Type visit(SuperMethodCall node) {
-      Type t = context.getSuperType(ts);
+      DJClass c = resolveThis(node.getClassName(), node);
+      Type t = c.immediateSuperclass();
       if (t == null) {
         throw new ExecutionError("super.undefined", node);
       }
@@ -660,7 +666,7 @@ else if (ts.containsClass(classType, memberName.image())) {
         checkThrownExceptions(inv.thrown(), node);
         node.setArguments(CollectUtil.makeList(inv.args()));
         setMethod(node, inv.method());
-        setDJClass(node, context.getThis());
+        setDJClass(node, c);
         Type result = ts.capture(inv.returnType());
         debug.logValue("Type of method call " + node.getMethodName(), ts.wrap(result));
         addRuntimeCheck(node, result, inv.method().returnType());
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/FunctionContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/FunctionContext.java
@@ -79,11 +79,6 @@ private boolean isLocalFunction(String name) {
     else { return super.getThis(className); }
   }
   
-  @Override public Type getSuperType(TypeSystem ts) {
-    if (isStatic()) { return null; }
-    else { return super.getSuperType(ts); }
-  }
-  
   @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/TypeContext.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/TypeContext.java
@@ -135,12 +135,6 @@ public interface TypeContext {
    */
   public DJClass getThis(String className);
   
-  /**
-   * Return the type referenced by {@code super} in the current context, or {@code null}
-   * if there is no such type (for example, in a static context).
-   */
-  public Type getSuperType(TypeSystem ts);
-  
   /**
    * 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/sourcechecker/SourceChecker.java b/dynamicjava/src/edu/rice/cs/dynamicjava/sourcechecker/SourceChecker.java
@@ -110,7 +110,10 @@ public static void main(String... args) {
       new SourceChecker(opt).check(sources, cp);
       System.out.println("Completed checking successfully.");
     }
-    catch (InterpreterException e) { e.printUserMessage(new PrintWriter(System.out, true)); }
+    catch (InterpreterException e) {
+      debug.log(e);
+      e.printUserMessage(new PrintWriter(System.out, true));
+    }
   }
   
 }
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/symbol/DJClass.java b/dynamicjava/src/edu/rice/cs/dynamicjava/symbol/DJClass.java
@@ -2,6 +2,7 @@
 
 import edu.rice.cs.dynamicjava.symbol.type.Type;
 import edu.rice.cs.dynamicjava.symbol.type.VariableType;
+import edu.rice.cs.plt.tuple.Option;
 
 /** Represents a class declaration. */
 public interface DJClass {
@@ -39,7 +40,7 @@ public interface DJClass {
   
   /** List the declared supertypes of this class */
   public Iterable<Type> declaredSupertypes();
-  
+
   public Iterable<DJField> declaredFields();
   
   public Iterable<DJConstructor> declaredConstructors();
diff --git a/dynamicjava/src/koala/dynamicjava/parser/grammar.jj b/dynamicjava/src/koala/dynamicjava/parser/grammar.jj
@@ -276,7 +276,8 @@ public class Parser {
     
     @Override public Primary dotThis(Option<List<TypeName>> targs, Token t) throws ParseException {
       if (targs.isNone()) {
-        return new ExpressionPrimary(new ThisExpression(ids(), _range(this, t)));
+        Option<String> cn = Option.some(TreeUtilities.listToName(ids()));
+        return new ExpressionPrimary(new ThisExpression(cn, _range(this, t)));
       }
       else { return _throwParseException("Unexpected type arguments"); }
     }
@@ -480,7 +481,7 @@ public class Parser {
   class ThisExpressionPrimary extends CompletedPrimary {
     public ThisExpressionPrimary(Token t) { super(_range(t, t)); }
     public Expression asExpression() {
-      return new ThisExpression(new LinkedList<IdentifierToken>(), getSourceInfo());
+      return new ThisExpression(Option.<String>none(), getSourceInfo());
     }
     @Override public Primary withArgs(List<Expression> args, Token last) {
       return new ConstructorCallPrimary(new ConstructorCall(null, args, false, _range(this, last)));
@@ -511,8 +512,9 @@ public class Parser {
       _ids = ids;
     }
     @Override public Primary dotId(Option<List<TypeName>> targs, Token id) {
-      if (targs.isNone()) { return new SuperFieldAccessPrimary(_ids, id, _range(this, id)); }
-      else { return new PartialSuperMethodCallPrimary(_ids, targs, id, _range(this, id)); }
+      Option<String> cn = (_ids == null) ? Option.<String>none() : Option.some(TreeUtilities.listToName(_ids));
+      if (targs.isNone()) { return new SuperFieldAccessPrimary(cn, id, _range(this, id)); }
+      else { return new PartialSuperMethodCallPrimary(cn, targs, id, _range(this, id)); }
     }
     @Override public Primary withArgs(List<Expression> args, Token last) {
       Expression outer = null;
@@ -548,20 +550,18 @@ public class Parser {
    * method arguments.
    */
   class SuperFieldAccessPrimary extends CompletedPrimary {
-    private final List<IdentifierToken> _className; // may be null
+    private final Option<String> _className;
     private final String _name;
-    public SuperFieldAccessPrimary(List<IdentifierToken> className, Token id, SourceInfo si) {
+    public SuperFieldAccessPrimary(Option<String> className, Token id, SourceInfo si) {
       super(si);
       _className = className;
       _name = id.image;
     }
     public Expression asExpression() throws ParseException {
-      if (_className != null) { return _throwParseException("Qualified super field accesses are not yet supported"); }
-      return new SuperFieldAccess(_name, getSourceInfo());
+      return new SuperFieldAccess(_className, _name, getSourceInfo());
     }
     @Override public Primary withArgs(List<Expression> args, Token last) throws ParseException {
-      if (_className != null) { return _throwParseException("Qualified super method calls are not yet supported"); }
-      return new ExpressionPrimary(new SuperMethodCall(_name, args, _range(this, last))); 
+      return new ExpressionPrimary(new SuperMethodCall(_className, _name, args, _range(this, last))); 
     }
   }
   
@@ -570,21 +570,24 @@ public class Parser {
    * a method name.
    */
   class PartialSuperMethodCallPrimary extends Primary {
-    private final List<IdentifierToken> _className; // may be null
+    private final Option<String> _className;
     private final Option<List<TypeName>> _targs;
     private final String _name;
-    PartialSuperMethodCallPrimary(List<IdentifierToken> className, Option<List<TypeName>> targs, Token id,
+    PartialSuperMethodCallPrimary(Option<String> className, Option<List<TypeName>> targs, Token id,
                                   SourceInfo si) {
       super(si);
       _className = className;
       _targs = targs;
       _name = id.image;
     }
     @Override public Primary withArgs(List<Expression> args, Token last) throws ParseException {
-      if (_className != null) { _throwParseException("Qualified super method calls are not yet supported"); }
       SourceInfo si = _range(this, last);
-      if (_targs.isNone()) { return new ExpressionPrimary(new SuperMethodCall(_name, args, si)); }
-      else { return new ExpressionPrimary(new PolymorphicSuperMethodCall(_name, args, _targs.unwrap(), si)); }  
+      if (_targs.isNone()) {
+        return new ExpressionPrimary(new SuperMethodCall(_className, _name, args, si));
+      }
+      else {
+        return new ExpressionPrimary(new PolymorphicSuperMethodCall(_className, _name, args, _targs.unwrap(), si));
+      }  
     }
   }
   
@@ -1721,7 +1724,7 @@ PARSER_END(Parser)
         ( "[" "]" { dim++; } )*
           [ "throws" exceptions=ReferenceTypeNameList() ]
           (
-            LOOKAHEAD({ !level.equals(DeclType.INTERFACE_MEMBER) }) body=block()
+            body=block()
           | ";"
           )
         {
@@ -1748,11 +1751,11 @@ PARSER_END(Parser)
           }
           
           if (typeParameters == null) {
-            return new MethodDeclaration(mods, typ, id.image, params, exceptions, body, _range(mods, body));
+            return new MethodDeclaration(mods, typ, id.image, params, exceptions, body, _range(mods, token));
           }
           else {
             return new PolymorphicMethodDeclaration(mods, typ, id.image, params, exceptions, body, typeParameters,
-                                                    _range(mods, body));
+                                                    _range(mods, token));
           }
         }
     }
@@ -1985,6 +1988,7 @@ PARSER_END(Parser)
         node = unmodifiedTypeDeclaration(mods, DeclType.INTERFACE_MEMBER)
       | LOOKAHEAD(methodLookahead()) node=unmodifiedMethodDeclaration(mods, DeclType.INTERFACE_MEMBER)
       | LOOKAHEAD(variableLookahead()) list=unmodifiedVariableDeclaration(mods, DeclType.INTERFACE_MEMBER)
+      | ";"
       )
       {
         if (node != null) { list.add(node); }
@@ -2051,8 +2055,7 @@ PARSER_END(Parser)
   }
   {
     [ consts = enumConstants() ]
-    ";"
-    ( ns = classBodyDeclaration() { decls.addAll(ns); } )*
+    [";" ( ns = classBodyDeclaration() { decls.addAll(ns); } )* ]
     {
       return new EnumDeclaration.EnumBody((consts==null) ? new LinkedList<EnumDeclaration.EnumConstant>() : consts,
                                           decls);
diff --git a/dynamicjava/src/koala/dynamicjava/parser/wrapper/ParserTest.java b/dynamicjava/src/koala/dynamicjava/parser/wrapper/ParserTest.java
@@ -47,6 +47,7 @@
 
 import edu.rice.cs.plt.collect.CollectUtil;
 import edu.rice.cs.plt.iter.IterUtil;
+import edu.rice.cs.plt.tuple.Option;
 import edu.rice.cs.plt.tuple.Pair;
 
 import static koala.dynamicjava.tree.ModifierSet.Modifier.*;
@@ -586,9 +587,7 @@ public void testQualifiedNameFieldAccess() throws ParseException {
   }
   
   public void testDotThis() throws ParseException {
-    List<IdentifierToken> ident = new LinkedList<IdentifierToken>();
-    ident.add(new Identifier("List"));
-    Expression expected = new ThisExpression(ident, SourceInfo.NONE);
+    Expression expected = new ThisExpression(Option.some("List"), SourceInfo.NONE);
     verifyExprOutput("List.this", expected);
   }
   
@@ -608,7 +607,7 @@ public void testMemberAccess()  throws ParseException {
   }
   
   public void testSuperMemberAccess()  throws ParseException {
-    Expression expected = new SuperFieldAccess("d");
+    Expression expected = new SuperFieldAccess(Option.<String>none(), "d");
     verifyExprOutput("super.d", expected);
   }
   
diff --git a/dynamicjava/src/koala/dynamicjava/tree/SuperFieldAccess.java b/dynamicjava/src/koala/dynamicjava/tree/SuperFieldAccess.java
diff --git a/dynamicjava/src/koala/dynamicjava/tree/SuperMethodCall.java b/dynamicjava/src/koala/dynamicjava/tree/SuperMethodCall.java
diff --git a/dynamicjava/src/koala/dynamicjava/tree/ThisExpression.java b/dynamicjava/src/koala/dynamicjava/tree/ThisExpression.java
diff --git a/dynamicjava/src/koala/dynamicjava/tree/tiger/PolymorphicSuperMethodCall.java b/dynamicjava/src/koala/dynamicjava/tree/tiger/PolymorphicSuperMethodCall.java
diff --git a/dynamicjava/src/koala/dynamicjava/util/DisplayVisitor.java b/dynamicjava/src/koala/dynamicjava/util/DisplayVisitor.java

Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,10 @@ public static void main(String... args) {`
`110`	`110`	`new SourceChecker(opt).check(sources, cp);`
`111`	`111`	`System.out.println("Completed checking successfully.");`
`112`	`112`	`}`
`113`		`- catch (InterpreterException e) { e.printUserMessage(new PrintWriter(System.out, true)); }`
	`113`	`+ catch (InterpreterException e) {`
	`114`	`+ debug.log(e);`
	`115`	`+ e.printUserMessage(new PrintWriter(System.out, true));`
	`116`	`+ }`
`114`	`117`	`}`
`115`	`118`
`116`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -276,7 +276,8 @@ public class Parser {`
`276`	`276`
`277`	`277`	`@Override public Primary dotThis(Option<List<TypeName>> targs, Token t) throws ParseException {`
`278`	`278`	`if (targs.isNone()) {`
`279`		`- return new ExpressionPrimary(new ThisExpression(ids(), _range(this, t)));`
	`279`	`+ Option<String> cn = Option.some(TreeUtilities.listToName(ids()));`
	`280`	`+ return new ExpressionPrimary(new ThisExpression(cn, _range(this, t)));`
`280`	`281`	`}`
`281`	`282`	`else { return _throwParseException("Unexpected type arguments"); }`
`282`	`283`	`}`
`@@ -480,7 +481,7 @@ public class Parser {`
`480`	`481`	`class ThisExpressionPrimary extends CompletedPrimary {`
`481`	`482`	`public ThisExpressionPrimary(Token t) { super(_range(t, t)); }`
`482`	`483`	`public Expression asExpression() {`
`483`		`- return new ThisExpression(new LinkedList<IdentifierToken>(), getSourceInfo());`
	`484`	`+ return new ThisExpression(Option.<String>none(), getSourceInfo());`
`484`	`485`	`}`
`485`	`486`	`@Override public Primary withArgs(List<Expression> args, Token last) {`
`486`	`487`	`return new ConstructorCallPrimary(new ConstructorCall(null, args, false, _range(this, last)));`
`@@ -511,8 +512,9 @@ public class Parser {`
`511`	`512`	`_ids = ids;`
`512`	`513`	`}`
`513`	`514`	`@Override public Primary dotId(Option<List<TypeName>> targs, Token id) {`
`514`		`- if (targs.isNone()) { return new SuperFieldAccessPrimary(_ids, id, _range(this, id)); }`
`515`		`- else { return new PartialSuperMethodCallPrimary(_ids, targs, id, _range(this, id)); }`
	`515`	`+ Option<String> cn = (_ids == null) ? Option.<String>none() : Option.some(TreeUtilities.listToName(_ids));`
	`516`	`+ if (targs.isNone()) { return new SuperFieldAccessPrimary(cn, id, _range(this, id)); }`
	`517`	`+ else { return new PartialSuperMethodCallPrimary(cn, targs, id, _range(this, id)); }`
`516`	`518`	`}`
`517`	`519`	`@Override public Primary withArgs(List<Expression> args, Token last) {`
`518`	`520`	`Expression outer = null;`
`@@ -548,20 +550,18 @@ public class Parser {`
`548`	`550`	`* method arguments.`
`549`	`551`	`*/`
`550`	`552`	`class SuperFieldAccessPrimary extends CompletedPrimary {`
`551`		`- private final List<IdentifierToken> _className; // may be null`
	`553`	`+ private final Option<String> _className;`
`552`	`554`	`private final String _name;`
`553`		`- public SuperFieldAccessPrimary(List<IdentifierToken> className, Token id, SourceInfo si) {`
	`555`	`+ public SuperFieldAccessPrimary(Option<String> className, Token id, SourceInfo si) {`
`554`	`556`	`super(si);`
`555`	`557`	`_className = className;`
`556`	`558`	`_name = id.image;`
`557`	`559`	`}`
`558`	`560`	`public Expression asExpression() throws ParseException {`
`559`		`- if (_className != null) { return _throwParseException("Qualified super field accesses are not yet supported"); }`
`560`		`- return new SuperFieldAccess(_name, getSourceInfo());`
	`561`	`+ return new SuperFieldAccess(_className, _name, getSourceInfo());`
`561`	`562`	`}`
`562`	`563`	`@Override public Primary withArgs(List<Expression> args, Token last) throws ParseException {`
`563`		`- if (_className != null) { return _throwParseException("Qualified super method calls are not yet supported"); }`
`564`		`- return new ExpressionPrimary(new SuperMethodCall(_name, args, _range(this, last)));`
	`564`	`+ return new ExpressionPrimary(new SuperMethodCall(_className, _name, args, _range(this, last)));`
`565`	`565`	`}`
`566`	`566`	`}`
`567`	`567`
`@@ -570,21 +570,24 @@ public class Parser {`
`570`	`570`	`* a method name.`
`571`	`571`	`*/`
`572`	`572`	`class PartialSuperMethodCallPrimary extends Primary {`
`573`		`- private final List<IdentifierToken> _className; // may be null`
	`573`	`+ private final Option<String> _className;`
`574`	`574`	`private final Option<List<TypeName>> _targs;`
`575`	`575`	`private final String _name;`
`576`		`- PartialSuperMethodCallPrimary(List<IdentifierToken> className, Option<List<TypeName>> targs, Token id,`
	`576`	`+ PartialSuperMethodCallPrimary(Option<String> className, Option<List<TypeName>> targs, Token id,`
`577`	`577`	`SourceInfo si) {`
`578`	`578`	`super(si);`
`579`	`579`	`_className = className;`
`580`	`580`	`_targs = targs;`
`581`	`581`	`_name = id.image;`
`582`	`582`	`}`
`583`	`583`	`@Override public Primary withArgs(List<Expression> args, Token last) throws ParseException {`
`584`		`- if (_className != null) { _throwParseException("Qualified super method calls are not yet supported"); }`
`585`	`584`	`SourceInfo si = _range(this, last);`
`586`		`- if (_targs.isNone()) { return new ExpressionPrimary(new SuperMethodCall(_name, args, si)); }`
`587`		`- else { return new ExpressionPrimary(new PolymorphicSuperMethodCall(_name, args, _targs.unwrap(), si)); }`
	`585`	`+ if (_targs.isNone()) {`
	`586`	`+ return new ExpressionPrimary(new SuperMethodCall(_className, _name, args, si));`
	`587`	`+ }`
	`588`	`+ else {`
	`589`	`+ return new ExpressionPrimary(new PolymorphicSuperMethodCall(_className, _name, args, _targs.unwrap(), si));`
	`590`	`+ }`
`588`	`591`	`}`
`589`	`592`	`}`
`590`	`593`
`@@ -1721,7 +1724,7 @@ PARSER_END(Parser)`
`1721`	`1724`	`( "[" "]" { dim++; } )*`
`1722`	`1725`	`[ "throws" exceptions=ReferenceTypeNameList() ]`
`1723`	`1726`	`(`
`1724`		`- LOOKAHEAD({ !level.equals(DeclType.INTERFACE_MEMBER) }) body=block()`
	`1727`	`+ body=block()`
`1725`	`1728`	`\| ";"`
`1726`	`1729`	`)`
`1727`	`1730`	`{`
`@@ -1748,11 +1751,11 @@ PARSER_END(Parser)`
`1748`	`1751`	`}`
`1749`	`1752`
`1750`	`1753`	`if (typeParameters == null) {`
`1751`		`- return new MethodDeclaration(mods, typ, id.image, params, exceptions, body, _range(mods, body));`
	`1754`	`+ return new MethodDeclaration(mods, typ, id.image, params, exceptions, body, _range(mods, token));`
`1752`	`1755`	`}`
`1753`	`1756`	`else {`
`1754`	`1757`	`return new PolymorphicMethodDeclaration(mods, typ, id.image, params, exceptions, body, typeParameters,`
`1755`		`- _range(mods, body));`
	`1758`	`+ _range(mods, token));`
`1756`	`1759`	`}`
`1757`	`1760`	`}`
`1758`	`1761`	`}`
`@@ -1985,6 +1988,7 @@ PARSER_END(Parser)`
`1985`	`1988`	`node = unmodifiedTypeDeclaration(mods, DeclType.INTERFACE_MEMBER)`
`1986`	`1989`	`\| LOOKAHEAD(methodLookahead()) node=unmodifiedMethodDeclaration(mods, DeclType.INTERFACE_MEMBER)`
`1987`	`1990`	`\| LOOKAHEAD(variableLookahead()) list=unmodifiedVariableDeclaration(mods, DeclType.INTERFACE_MEMBER)`
	`1991`	`+ \| ";"`
`1988`	`1992`	`)`
`1989`	`1993`	`{`
`1990`	`1994`	`if (node != null) { list.add(node); }`
`@@ -2051,8 +2055,7 @@ PARSER_END(Parser)`
`2051`	`2055`	`}`
`2052`	`2056`	`{`
`2053`	`2057`	`[ consts = enumConstants() ]`
`2054`		`- ";"`
`2055`		`- ( ns = classBodyDeclaration() { decls.addAll(ns); } )*`
	`2058`	`+ [";" ( ns = classBodyDeclaration() { decls.addAll(ns); } )* ]`
`2056`	`2059`	`{`
`2057`	`2060`	`return new EnumDeclaration.EnumBody((consts==null) ? new LinkedList<EnumDeclaration.EnumConstant>() : consts,`
`2058`	`2061`	`decls);`