Validate the target of break and continue statments from within a switch

compiler/java/com/google/dart/compiler/resolver/Resolver.java

 // 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.
 
 package com.google.dart.compiler.resolver;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.google.dart.compiler.DartCompilationPhase;
 import com.google.dart.compiler.DartCompilerContext;
 import com.google.dart.compiler.ErrorCode;
 import com.google.dart.compiler.ast.DartArrayLiteral;
 import com.google.dart.compiler.ast.DartBinaryExpression;
 import com.google.dart.compiler.ast.DartBlock;
 import com.google.dart.compiler.ast.DartBooleanLiteral;
 import com.google.dart.compiler.ast.DartBreakStatement;
 import com.google.dart.compiler.ast.DartCatchBlock;
 import com.google.dart.compiler.ast.DartClass;
 import com.google.dart.compiler.ast.DartClassMember;
+import com.google.dart.compiler.ast.DartContinueStatement;
 import com.google.dart.compiler.ast.DartDoWhileStatement;
 import com.google.dart.compiler.ast.DartDoubleLiteral;
 import com.google.dart.compiler.ast.DartExpression;
 import com.google.dart.compiler.ast.DartField;
 import com.google.dart.compiler.ast.DartFieldDefinition;
 import com.google.dart.compiler.ast.DartForInStatement;
 import com.google.dart.compiler.ast.DartForStatement;
 import com.google.dart.compiler.ast.DartFunction;
 import com.google.dart.compiler.ast.DartFunctionExpression;
 import com.google.dart.compiler.ast.DartFunctionObjectInvocation;
@@ skipping 31 matching lines @@
 import com.google.dart.compiler.ast.DartTypeParameter;
 import com.google.dart.compiler.ast.DartUnit;
 import com.google.dart.compiler.ast.DartUnqualifiedInvocation;
 import com.google.dart.compiler.ast.DartVariable;
 import com.google.dart.compiler.ast.DartVariableStatement;
 import com.google.dart.compiler.ast.DartWhileStatement;
 import com.google.dart.compiler.ast.Modifiers;
 import com.google.dart.compiler.common.HasSourceInfo;
 import com.google.dart.compiler.common.SourceInfo;
 import com.google.dart.compiler.parser.Token;
+import com.google.dart.compiler.resolver.LabelElement.LabeledStatementType;
 import com.google.dart.compiler.type.InterfaceType;
 import com.google.dart.compiler.type.InterfaceType.Member;
 import com.google.dart.compiler.type.Type;
 import com.google.dart.compiler.type.TypeKind;
 import com.google.dart.compiler.type.TypeVariable;
 import com.google.dart.compiler.type.Types;
 import com.google.dart.compiler.util.apache.StringUtils;
 
 import java.util.EnumSet;
 import java.util.Iterator;
@@ skipping 664 matching lines @@
       for (DartVariable variable : node.getVariables()) {
         String name = variable.getVariableName();
         getContext().getScope().removeDeclaredButNotReachedVariable(name);
         Elements.setType(resolveVariable(variable, node.getModifiers()), type);
         checkVariableStatement(node, variable, isImplicitlyInitialized);
       }
      }
 
     @Override
     public Element visitLabel(DartLabel x) {
-      LabelElement currentLabel = Elements.labelElement(x, x.getName(), innermostFunction);
-      recordElement(x.getLabel(), currentLabel);
-      recordElement(x, currentLabel);
+      DartNode parent = x.getParent();
+      if (!(parent instanceof DartSwitchMember)) {
+        LabelElement labelElement;
+        DartStatement childStatement = x.getStatement();
+        while (childStatement instanceof DartLabel) {
+          childStatement = ((DartLabel)childStatement).getStatement();
+        }
+        if (childStatement instanceof DartSwitchStatement) {
+          labelElement = Elements.switchLabelElement(x, x.getName(), innermostFunction);
+        } else {
+          labelElement = Elements.statementLabelElement(x, x.getName(), innermostFunction);
+        }
+        recordElement(x.getLabel(), labelElement);
+        recordElement(x, labelElement);
+      }
       x.visitChildren(this);
-      if (!labelsInScopes.contains(currentLabel)) {
-        // TODO(zundel): warning, not type error.
-        // topLevelContext.typeError(x, DartCompilerErrorCode.USELESS_LABEL, x.getName());
-      } else if (!referencedLabels.contains(currentLabel)) {
-        // TODO(zundel): warning, not type error.
-        // topLevelContext.typeError(x, DartCompilerErrorCode.UNREFERENCED_LABEL, x.getName());
-      }
       return null;
     }
 
     @Override
     public Element visitFunctionExpression(DartFunctionExpression x) {
       MethodElement element;
       if (x.isStatement()) {
         // Function statement names live in the outer scope.
         element = getContext().declareFunction(x);
         getContext().pushFunctionScope(x);
@@ skipping 119 matching lines @@
         resolveVariableStatement(x.getVariableStatement(), true);
       } else {
         x.getIdentifier().accept(this);
       }
       x.getIterable().accept(this);
       x.getBody().accept(this);
       getContext().popScope();
       return null;
     }
 
-    private void addLabelToStatement(DartStatement x) {
+    private void addLabelToStatement(DartNode x) {
       DartNode parent = x.getParent();
       while (parent instanceof DartLabel) {
-        LabelElement currentLabel = ((DartLabel) parent).getElement();
+        DartLabel label = (DartLabel) parent;
+        LabelElement currentLabel = label.getElement();
         getContext().getScope().addLabel(currentLabel);
         labelsInScopes.add(currentLabel);
         parent = parent.getParent();
       }
     }
 
-    private void addLabelToSwitchMember(DartSwitchMember x) {
-      DartLabel label = x.getLabel();
-      if (label != null) {
-        LabelElement currentLabel = label.getElement();  // TODO(zundel): Y U NO HAVE ELEMENT?
-        if (getContext().getScope().hasLocalLabel(label.getName())) {
-          onError(label, ResolverErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT);
-        }
-        getContext().getScope().addLabel(currentLabel);
-        labelsInScopes.add(currentLabel);
-      }
-    }
-
-
     @Override
     public Element visitForStatement(DartForStatement x) {
       getContext().pushScope("<for>");
       addLabelToStatement(x);
       x.visitChildren(this);
       getContext().popScope();
       return null;
     }
 
 
     @Override
     public Element visitSwitchStatement(DartSwitchStatement x) {
       getContext().pushScope("<switch>");
       addLabelToStatement(x);
+      // The scope of a label on the case statement is the case statement itself. These labels
+      // need to be resolved before the continue <label>; statements can be resolved.
+      for (DartSwitchMember member : x.getMembers()) {
+        recordSwitchMamberLabel(member);
+      }
       x.visitChildren(this);
       getContext().popScope();
       return null;
     }
 
     @Override
     public Element visitSwitchMember(DartSwitchMember x) {
       getContext().pushScope("<switch member>");
       x.visitChildren(this);
       getContext().popScope();
-      // The scope of a label on the case statement is the case statement itself.
-      addLabelToSwitchMember(x);
       return null;
     }
 
+    private void recordSwitchMamberLabel(DartSwitchMember x) {
+      DartLabel label = x.getLabel();
+      if (label != null) {
+        LabelElement labelElement =  Elements.switchMemberLabelElement(label, label.getName(),
+            innermostFunction);
+        recordElement(label.getLabel(), labelElement);
+        recordElement(label, labelElement);
+        if (getContext().getScope().hasLocalLabel(label.getName())) {
+          onError(label, ResolverErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT);
+        }
+        getContext().getScope().addLabel(labelElement);
+        labelsInScopes.add(labelElement);
+      }
+    }
+
     @Override
     public Element visitThisExpression(DartThisExpression x) {
       if (ElementKind.of(currentHolder).equals(ElementKind.LIBRARY)) {
         onError(x, ResolverErrorCode.THIS_ON_TOP_LEVEL);
       } else if (currentMethod == null) {
         onError(x, ResolverErrorCode.THIS_OUTSIDE_OF_METHOD);
       } else if (currentMethod.getModifiers().isStatic()) {
         onError(x, ResolverErrorCode.THIS_IN_STATIC_METHOD);
       } else if (currentMethod.getModifiers().isFactory()) {
         onError(x, ResolverErrorCode.THIS_IN_FACTORY_CONSTRUCTOR);
@@ skipping 593 matching lines @@
       }
     }
 
     @Override
     public Element visitGotoStatement(DartGotoStatement x) {
       // Don't bother unless there's a target.
       if (x.getTargetName() != null) {
         Element element = getContext().getScope().findLabel(x.getTargetName(), innermostFunction);
         if (ElementKind.of(element).equals(ElementKind.LABEL)) {
           LabelElement labelElement = (LabelElement) element;
+          if (x instanceof DartBreakStatement
+              && labelElement.getStatementType() == LabeledStatementType.SWITCH_MEMBER_STATEMENT) {
+            onError(x.getLabel(), ResolverErrorCode.BREAK_LABEL_RESOLVES_TO_CASE_OR_DEFAULT);
+            return null;
+          }
+          if (x instanceof DartContinueStatement
+              && labelElement.getStatementType() == LabeledStatementType.SWITCH_STATEMENT) {
+            onError(x.getLabel(), ResolverErrorCode.CONTINUE_LABEL_RESOLVES_TO_SWITCH);
+            return null;
+          }
           MethodElement enclosingFunction = (labelElement).getEnclosingFunction();
           if (enclosingFunction == innermostFunction) {
             referencedLabels.add(labelElement);
             return recordElement(x, element);
           }
         }
         diagnoseErrorInGotoStatement(x, element);
       }
       return null;
     }
@@ skipping 27 matching lines @@
                       classOrLibrary.getName());
               break;
             default:
               onError(errorNode, ResolverErrorCode.CANNOT_RESOLVE_METHOD, name);
           }
 
           break;
 
         case CONSTRUCTOR:
           onError(errorNode, ResolverErrorCode.IS_A_CONSTRUCTOR, classOrLibrary.getName(),
-                          name);
+              name);
           break;
 
         case METHOD: {
           assert !((MethodElement) element).getModifiers().isStatic();
           onError(errorNode, ResolverErrorCode.IS_AN_INSTANCE_METHOD,
               classOrLibrary.getName(), name);
           break;
         }
 
         default:
@@ skipping 512 matching lines @@
         ClassElement nextClass = (ClassElement) nextConstructorElement.getEnclosingElement();
         ClassElement currentClass = (ClassElement) constructor.getEnclosingElement();
         if (nextClass == currentClass) {
           return (ConstructorNodeElement) nextConstructorElement;
         }
       }
     }
     return null;
   }
 }