Check enums in switch cases.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 2891 matching lines @@
           // Potentially a 'dynamic' type literal.
           type = registry.getType(node.selector);
         }
         if (type == null) {
           type = target.computeType(compiler);
         }
         registry.registerTypeLiteral(node, type);
 
         // Don't try to make constants of calls to type literals.
         if (!node.isCall) {
-          analyzeConstant(node);
+          analyzeConstantDeferred(node);
         } else {
           // The node itself is not a constant but we register the selector (the
           // identifier that refers to the class/typedef) as a constant.
-          analyzeConstant(node.selector);
+          analyzeConstantDeferred(node.selector);
         }
       }
       if (isPotentiallyMutableTarget(target)) {
         if (enclosingElement != target.enclosingElement) {
           for (Node scope in promotionScope) {
             registry.setAccessedByClosureIn(scope, target, node);
           }
         }
       }
     }
@@ skipping 243 matching lines @@
 
   visitLiteralSymbol(LiteralSymbol node) {
     registry.registerInstantiatedClass(compiler.symbolClass);
     registry.registerStaticUse(compiler.symbolConstructor.declaration);
     registry.registerConstSymbol(node.slowNameString);
     if (!validateSymbol(node, node.slowNameString, reportError: false)) {
       compiler.reportError(node,
           MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
           {'value': node.slowNameString});
     }
-    analyzeConstant(node);
+    analyzeConstantDeferred(node);
   }
 
   visitStringJuxtaposition(StringJuxtaposition node) {
     registry.registerInstantiatedClass(compiler.stringClass);
     node.visitChildren(this);
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       visit(link.head);
@@ skipping 230 matching lines @@
           compiler.reportHint(
               node.newToken, MessageKind.NON_CONST_BLOAT,
               {'name': compiler.symbolClass.name});
         }
         registry.registerNewSymbol();
       }
     } else if (isMirrorsUsedConstant) {
       compiler.mirrorUsageAnalyzerTask.validate(node, registry.mapping);
     }
     if (node.isConst) {
-      analyzeConstant(node);
+      analyzeConstantDeferred(node);
     }
 
     return null;
   }
 
   void checkConstMapKeysDontOverrideEquals(Spannable spannable,
                                            MapConstantValue map) {
     for (ConstantValue key in map.keys) {
       if (!key.isObject) continue;
       ObjectConstantValue objectConstant = key;
       DartType keyType = objectConstant.type;
       ClassElement cls = keyType.element;
       if (cls == compiler.stringClass) continue;
       Element equals = cls.lookupMember('==');
       if (equals.enclosingClass != compiler.objectClass) {
         compiler.reportError(spannable,
                              MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
                              {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node) {
-    addDeferredAction(enclosingElement, () {
-      ConstantExpression constant =
-          compiler.resolver.constantCompiler.compileNode(
-              node, registry.mapping);
+    ConstantExpression constant =
+        compiler.resolver.constantCompiler.compileNode(
+            node, registry.mapping);
 
-      ConstantValue value = constant.value;
-      if (value.isMap) {
-        checkConstMapKeysDontOverrideEquals(node, value);
-      }
+    ConstantValue value = constant.value;
+    if (value.isMap) {
+      checkConstMapKeysDontOverrideEquals(node, value);
+    }
 
-      // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
-      // a class that will be instantiated outside the program by attaching a
-      // native class dispatch record referencing the interceptor.
-      if (argumentsToJsInterceptorConstant != null &&
-          argumentsToJsInterceptorConstant.contains(node)) {
-        if (value.isType) {
-          TypeConstantValue typeConstant = value;
-          if (typeConstant.representedType is InterfaceType) {
-            registry.registerInstantiatedType(typeConstant.representedType);
-          } else {
-            compiler.reportError(node,
-                MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
-          }
+    // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
+    // a class that will be instantiated outside the program by attaching a
+    // native class dispatch record referencing the interceptor.
+    if (argumentsToJsInterceptorConstant != null &&
+        argumentsToJsInterceptorConstant.contains(node)) {
+      if (value.isType) {
+        TypeConstantValue typeConstant = value;
+        if (typeConstant.representedType is InterfaceType) {
+          registry.registerInstantiatedType(typeConstant.representedType);
         } else {
           compiler.reportError(node,
               MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
         }
+      } else {
+        compiler.reportError(node,
+            MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
       }
+    }
+  }
+
+  void analyzeConstantDeferred(Node node) {
+    addDeferredAction(enclosingElement, () {
+      analyzeConstant(node);
     });
   }
 
   bool validateSymbol(Node node, String name, {bool reportError: true}) {
     if (name.isEmpty) return true;
     if (name.startsWith('_')) {
       if (reportError) {
         compiler.reportError(node, MessageKind.PRIVATE_IDENTIFIER,
                              {'value': name});
       }
@@ skipping 69 matching lines @@
       listType = new InterfaceType(compiler.listClass, [typeArgument]);
     } else {
       compiler.listClass.computeType(compiler);
       listType = compiler.listClass.rawType;
     }
     registry.setType(node, listType);
     registry.registerInstantiatedType(listType);
     registry.registerRequiredType(listType, enclosingElement);
     visit(node.elements);
     if (node.isConst) {
-      analyzeConstant(node);
+      analyzeConstantDeferred(node);
     }
 
     sendIsMemberAccess = false;
   }
 
   visitConditional(Conditional node) {
     doInPromotionScope(node.condition, () => visit(node.condition));
     doInPromotionScope(node.thenExpression, () => visit(node.thenExpression));
     visit(node.elseExpression);
   }
@@ skipping 200 matching lines @@
           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
     }
     registry.setType(node, mapType);
     registry.registerInstantiatedType(mapType);
     if (node.isConst) {
       registry.registerConstantMap();
     }
     registry.registerRequiredType(mapType, enclosingElement);
     node.visitChildren(this);
     if (node.isConst) {
-      analyzeConstant(node);
+      analyzeConstantDeferred(node);
     }
 
     sendIsMemberAccess = false;
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
   }
 
   visitNamedArgument(NamedArgument node) {
@@ skipping 84 matching lines @@
       }
     }
   }
 
   visitSwitchStatement(SwitchStatement node) {
     node.expression.accept(this);
 
     JumpTarget breakElement = getOrDefineTarget(node);
     Map<String, LabelDefinition> continueLabels = <String, LabelDefinition>{};
     Link<Node> cases = node.cases.nodes;
+    List<Node> caseExpressions = <Node>[];
     while (!cases.isEmpty) {
       SwitchCase switchCase = cases.head;
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch != null) {
-          analyzeConstant(caseMatch.expression);
+          caseExpressions.add(caseMatch.expression);
           continue;
         }
         Label label = labelOrCase;
         String labelName = label.labelName;
 
         LabelDefinition existingElement = continueLabels[labelName];
         if (existingElement != null) {
           // It's an error if the same label occurs twice in the same switch.
           compiler.reportError(
               label,
@@ skipping 39 matching lines @@
       if (!label.isContinueTarget) {
         JumpTarget targetElement = label.target;
         SwitchCase switchCase = targetElement.statement;
         registry.undefineTarget(switchCase);
         registry.undefineLabel(label.label);
       }
     });
     // TODO(15575): We should warn if we can detect a fall through
     // error.
     registry.registerFallThroughError();
+
+    caseExpressions.forEach(analyzeConstant);
   }
 
   visitSwitchCase(SwitchCase node) {
     node.labelsAndCases.accept(this);
     visitIn(node.statements, new BlockScope(scope));
   }
 
   visitCaseMatch(CaseMatch node) {
     visit(node.expression);
   }
@@ skipping 381 matching lines @@
 
     invariant(node, element != null);
     invariant(element, element.resolutionState == STATE_STARTED,
         message: () => 'cyclic resolution of class $element');
 
     InterfaceType enumType = element.computeType(compiler);
     element.supertype = compiler.objectClass.computeType(compiler);
     element.interfaces = const Link<DartType>();
     calculateAllSupertypes(element);
 
+    if (node.names.nodes.isEmpty) {
+      compiler.reportError(node,
+                           MessageKind.EMPTY_ENUM_DECLARATION,
+                           {'enumName': element.name});
+    }
+
     EnumCreator creator = new EnumCreator(compiler, element);
     creator.createMembers();
     return enumType;
   }
 
   /// Resolves the mixed type for [mixinNode] and checks that the the mixin type
   /// is a valid, non-blacklisted interface type. The mixin type is returned.
   DartType checkMixinType(TypeAnnotation mixinNode) {
     DartType mixinType = resolveType(mixinNode);
     if (isBlackListed(mixinType)) {
@@ skipping 717 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }