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 1718 matching lines @@
     // unresolved methods. For instance [: foo(a: 42); :] where 'foo' is neither
     // found in the enclosing scope nor through lookup on 'this' or
     // [: x.foo(b: 42); :] where 'foo' cannot be not found through lookup on
     // the static type of 'x'.
     return analyze(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     // TODO(johnniwinther): Handle reachability based on reachability of
     // switch cases.
+    // TODO(johnniwinther): Provide hint of duplicate case constants.
 
     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) {
+      compiler.enqueuer.resolution.addDeferredAction(
+          elements.analyzedElement, () {
+        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);
+            }
+          }
+        }
+        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.');
   }
 }