Check enums in switch cases.

pkg/compiler/lib/src/typechecker.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 dart2js;
 
 class TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name => "Type checker";
 
@@ skipping 1722 matching lines @@
     return analyze(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     // TODO(johnniwinther): Handle reachability based on reachability of
     // switch cases.
 
     DartType expressionType = analyze(node.expression);
 
     // Check that all the case expressions are assignable to the expression.
+    bool hasDefaultCase = false;
     for (SwitchCase switchCase in node.cases) {
+      if (switchCase.isDefaultCase) {
+        hasDefaultCase = true;
+      }
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch == null) continue;
 
         DartType caseType = analyze(caseMatch.expression);
         checkAssignable(caseMatch, expressionType, caseType);
       }
 
       analyze(switchCase);
     }
 
+    if (!hasDefaultCase && expressionType.isEnumType) {
+      Map<ConstantValue, FieldElement> enumValues =
+          <ConstantValue, FieldElement>{};
+      List<FieldElement> unreferencedFields = <FieldElement>[];
+      EnumClassElement enumClass = expressionType.element;
+      enumClass.enumValues.forEach((FieldElement field) {
+        ConstantExpression constantExpression =
+            compiler.constants.getConstantForVariable(field);
+        if (constantExpression == null) {
+          // The field might not have been resolved.
+          unreferencedFields.add(field);
+        } else {
+          enumValues[constantExpression.value] = field;
+        }
+      });
+
+      for (SwitchCase switchCase in node.cases) {
+        for (Node labelOrCase in switchCase.labelsAndCases) {
+          CaseMatch caseMatch = labelOrCase.asCaseMatch();
+          if (caseMatch != null) {
+            ConstantExpression caseConstant =
+                compiler.resolver.constantCompiler.compileNode(
+                    caseMatch.expression, elements);
+            enumValues.remove(caseConstant.value);

[floitsch, 2014/11/12 17:52:35]

Do you want to add a check here to make sure that the same enum is not
referenced multiple times?

[Johnni Winther, 2014/11/13 08:48:40]

Not required by spec but should have a hint regardless of whether the case
expressions are enum or regular constants. Adding a TODO.

+          }
+        }
+      }
+      unreferencedFields.addAll(enumValues.values);
+      if (!unreferencedFields.isEmpty) {
+        compiler.reportWarning(node, MessageKind.MISSING_ENUM_CASES,
+            {'enumType': expressionType,
+             'enumValues': unreferencedFields.map((e) => e.name).join(', ')});
+      }
+    }
+
+
     return const StatementType();
   }
 
   visitSwitchCase(SwitchCase node) {
     return analyze(node.statements);
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(johnniwinther): Use reachability information of try-block,
     // catch-blocks and finally-block to compute the whether the try statement
@@ skipping 12 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     compiler.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }