DynamicJava: Fixed special scoping of switch constants for enum types (the constant must be an identifier naming a constant in the corresponding enum type)

dlsmith · dlsmith · commit 512658e6d0ae · 2009-09-18T19:32:29.000Z
git-svn-id: file:///tmp/test-svn/trunk@5072 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
@@ -215,6 +215,41 @@ public void checkConstructorCall(ConstructorCall node) {
     }
   }
   
+  /**
+   * Check an expression appearing as the switch case in an enum switch statement.
+   * @return  The field corresponding to the enum constant's value.
+   */
+  public DJField checkEnumSwitchCase(Expression exp, Type enumT) {
+    if (!(exp instanceof AmbiguousName)) {
+      throw new ExecutionError("invalid.enum.constant", exp);
+    }
+    List<IdentifierToken> ids = ((AmbiguousName) exp).getIdentifiers();
+    if (ids.size() != 1) {
+      throw new ExecutionError("invalid.enum.constant", exp);
+    }
+    String name = ids.get(0).image();
+    Expression translation = new SimpleFieldAccess(name);
+    try {
+      // Should actually verify that that the name is a declared enum constant, not just
+      // a static field.  But that requires a lot of unimplemented support where we're
+      // otherwise treating enums as syntactic sugar for normal class declarations.
+      StaticFieldReference ref = ts.lookupStaticField(enumT, name, context.accessModule());
+      setField(translation, ref.field());
+      Type t = ts.capture(ref.type());
+      if (!ts.isSubtype(t, enumT)) {
+        throw new ExecutionError("invalid.enum.constant", exp);
+      }
+      addRuntimeCheck(translation, t, ref.field().type());
+      setType(translation, t);
+      setType(exp, t);
+      setTranslation(exp, translation);
+      return ref.field();
+    }
+    catch (UnmatchedLookupException e) {
+      throw new ExecutionError("invalid.enum.constant", exp);
+    }
+  }
+  
   /**
    * Dynamically determines the appropriate error message type and initializes ERROR_STRINGS with the following:
    * {@code 0=type, 1=name, 2=targs, 3=args, 4=expected, 5=candidates}.
@@ -275,6 +310,12 @@ private void checkThrownExceptions(Iterable<? extends Type> thrownTypes, Node no
     }
   }
   
+  private void addRuntimeCheck(Node node, Type expectedType, Type declaredActualType) {
+    if (!ts.isSubtype(ts.erase(declaredActualType), ts.erase(expectedType))) {
+      setCheckedType(node, ts.erasedClass(expectedType));
+    }
+  }
+  
   private String nodeTypesString(Iterable<? extends Node> nodes, TypePrinter printer) {
     return printer.print(IterUtil.map(nodes, NODE_TYPE));
   }
@@ -752,12 +793,6 @@ private DJClass resolveThis(Option<String> outerName, Node node) {
       }
     }
     
-    private void addRuntimeCheck(Node node, Type expectedType, Type declaredActualType) {
-      if (!ts.isSubtype(ts.erase(declaredActualType), ts.erase(expectedType))) {
-        setCheckedType(node, ts.erasedClass(expectedType));
-      }
-    }
-    
     /** Visits an ArrayAllocation.  JLS 15.10.
       * @return  The type of the array
       */
diff --git a/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/StatementChecker.java b/dynamicjava/src/edu/rice/cs/dynamicjava/interpreter/StatementChecker.java
@@ -516,7 +516,8 @@ else if (ts.isIterable(collType)) {
    */
   @Override public TypeContext visit(SwitchStatement node) {
     Type t = checkType(node.getSelector());
-    if (!ts.isEnum(t)) {
+    boolean switchEnum = ts.isEnum(t);
+    if (!switchEnum) {
       try {
         Expression exp = ts.makePrimitive(node.getSelector());
         if (!(getType(exp) instanceof IntegralType) || (getType(exp) instanceof LongType)) {
@@ -538,16 +539,20 @@ else if (ts.isIterable(collType)) {
          - A local variable is in scope for the rest of the switch statement's body -- it "falls through"
          - A local class is *only* in scope in its SwitchBlock -- it does not "fall through"
          This is a mess.  For now we just follow a no-fall-through approach. */
-      
-      bk.acceptVisitor(this);
-      
       if (bk.getExpression() == null) {
         if (hasDefault) { throw new ExecutionError("duplicate.switch.case", node); }
         hasDefault = true;
       }
-      
+      else if (switchEnum) {
+        DJField val = new ExpressionChecker(context, opt).checkEnumSwitchCase(bk.getExpression(), t);
+        if (values.contains(val)) {
+          throw new ExecutionError("duplicate.switch.case", bk);
+        }
+        values.add(val);
+      }
       else {
         Expression exp = bk.getExpression();
+        checkType(exp);
         if (!hasValue(exp) || getValue(exp) == null) {
           throw new ExecutionError("invalid.constant", exp);
         }
@@ -556,12 +561,14 @@ else if (ts.isIterable(collType)) {
           throw new ExecutionError("switch.label.type", exp);
         }
         if (values.contains(getValue(exp))) { 
-          throw new ExecutionError("duplicate.switch.case", node);
+          throw new ExecutionError("duplicate.switch.case", bk);
         }
         values.add(getValue(exp));
       }
+      
+      if (bk.getStatements() != null) { checkList(bk.getStatements()); }
     }
-    
+      
     return context;
   }
 
diff --git a/dynamicjava/src/koala/dynamicjava/interpreter/resources/messages.properties b/dynamicjava/src/koala/dynamicjava/interpreter/resources/messages.properties
@@ -235,6 +235,8 @@ interface.member           = Illegal interface member
 
 # Used by ClassInfoCompiler, TypeChecker
 invalid.constant           = Invalid constant
+
+invalid.enum.constant      = Invalid enum constant name
   
 # Used by TypeChecker
 iterable.type              = Iterated type must be an array or an Iterable
