Issue 9845. Compare runtime types using ==.

pkg/analyzer_experimental/lib/src/generated/resolver.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.resolver;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
@@ skipping 995 matching lines @@
       _enclosingExecutable = outerExecutable;
     }
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     find3(_enclosingExecutable.localVariables, variableName);
     return super.visitDeclaredIdentifier(node);
   }
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     SimpleIdentifier parameterName = node.parameter.identifier;
-    ParameterElement element = find3(_enclosingExecutable.parameters, parameterName);
+    ParameterElement element = null;
+    if (_enclosingExecutable != null) {
+      element = find3(_enclosingExecutable.parameters, parameterName);
+    } else {
+      PrintStringWriter writer = new PrintStringWriter();
+      writer.println("Invalid state found in the Analysis Engine:");
+      writer.println("DeclarationResolver.visitDefaultFormalParameter() is visiting a parameter that does not appear to be in a method or function.");
+      writer.println("Ancestors:");
+      ASTNode parent14 = node.parent;
+      while (parent14 != null) {
+        writer.println(parent14.runtimeType.toString());
+        writer.println("---------");
+        parent14 = parent14.parent;
+      }
+      print(new AnalysisException());

[Brian Wilkerson, 2013/04/17 18:59:42]

Didn't this need to be "writer.print(...)"?

+      AnalysisEngine.instance.logger.logError(writer.toString());
+    }
     Expression defaultValue2 = node.defaultValue;
     if (defaultValue2 != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
         defaultValue2.accept(this);
       } finally {
@@ skipping 466 matching lines @@
     if (fieldElement != null && !fieldElement.isSynthetic()) {
       recordResolution(fieldName2, fieldElement);
     }
     return null;
   }
   Object visitConstructorName(ConstructorName node) {
     Type2 type14 = node.type.type;
     if (type14 is DynamicTypeImpl) {
       return null;
     } else if (type14 is! InterfaceType) {
-      ASTNode parent14 = node.parent;
-      if (parent14 is InstanceCreationExpression) {
-        if (((parent14 as InstanceCreationExpression)).isConst()) {
+      ASTNode parent15 = node.parent;

[Brian Wilkerson, 2013/04/17 18:59:42]

Enhancement request: It would be nice if we could remove local variables from
whatever data structure they're being added to when we leave a method so that we
don't have to have unique names across methods.

+      if (parent15 is InstanceCreationExpression) {
+        if (((parent15 as InstanceCreationExpression)).isConst()) {
         } else {
         }
       } else {
       }
       return null;
     }
     ClassElement classElement = ((type14 as InterfaceType)).element;
     ConstructorElement constructor;
     SimpleIdentifier name17 = node.name;
     if (name17 == null) {
@@ skipping 2155 matching lines @@
       }
     }
     return overrides;
   }
   /**
    * Return {@code true} if the given expression terminates abruptly (that is, if any expression
    * following the given expression will not be reached).
    * @param expression the expression being tested
    * @return {@code true} if the given expression terminates abruptly
    */
-  bool isAbruptTermination(Expression expression18) {
-    while (expression18 is ParenthesizedExpression) {
-      expression18 = ((expression18 as ParenthesizedExpression)).expression;
+  bool isAbruptTermination(Expression expression19) {
+    while (expression19 is ParenthesizedExpression) {
+      expression19 = ((expression19 as ParenthesizedExpression)).expression;
     }
-    return expression18 is ThrowExpression || expression18 is RethrowExpression;
+    return expression19 is ThrowExpression || expression19 is RethrowExpression;
   }
   /**
    * Return {@code true} if the given statement terminates abruptly (that is, if any statement
    * following the given statement will not be reached).
    * @param statement the statement being tested
    * @return {@code true} if the given statement terminates abruptly
    */
   bool isAbruptTermination2(Statement statement) {
     if (statement is ReturnStatement) {
       return true;
@@ skipping 1404 matching lines @@
    * @param library the library being tested
    * @return {@code true} if the library is 'dart:html'
    */
   bool isHtmlLibrary(LibraryElement library) => library.name == "dart.dom.html";
   /**
    * Return {@code true} if the given node is not a type literal.
    * @param node the node being tested
    * @return {@code true} if the given node is not a type literal
    */
   bool isNotTypeLiteral(Identifier node) {
-    ASTNode parent15 = node.parent;
-    return parent15 is TypeName || (parent15 is PrefixedIdentifier && (parent15.parent is TypeName || identical(((parent15 as PrefixedIdentifier)).prefix, node))) || (parent15 is PropertyAccess && identical(((parent15 as PropertyAccess)).target, node)) || (parent15 is MethodInvocation && identical(node, ((parent15 as MethodInvocation)).target));
+    ASTNode parent16 = node.parent;
+    return parent16 is TypeName || (parent16 is PrefixedIdentifier && (parent16.parent is TypeName || identical(((parent16 as PrefixedIdentifier)).prefix, node))) || (parent16 is PropertyAccess && identical(((parent16 as PropertyAccess)).target, node)) || (parent16 is MethodInvocation && identical(node, ((parent16 as MethodInvocation)).target));
   }
   /**
    * If it is appropriate to do so, override the type of the given element. Use the static type and
    * inferred type of the element to determine whether or not it is appropriate.
    * @param element the element whose type might be overridden
    * @param staticType the static type of the element
    * @param inferredType the inferred type of the element
    */
   void override(VariableElement element, Type2 staticType, Type2 inferredType) {
     if (identical(inferredType, BottomTypeImpl.instance) || element is! VariableElement) {
@@ skipping 608 matching lines @@
         return null;
       }
       VoidTypeImpl voidType = VoidTypeImpl.instance;
       if (typeName.name == voidType.name) {
         if (argumentList != null) {
         }
         typeName.staticType = voidType;
         node.type = voidType;
         return null;
       }
-      ASTNode parent16 = node.parent;
-      if (typeName is PrefixedIdentifier && parent16 is ConstructorName && argumentList == null) {
-        ConstructorName name = parent16 as ConstructorName;
+      ASTNode parent17 = node.parent;
+      if (typeName is PrefixedIdentifier && parent17 is ConstructorName && argumentList == null) {
+        ConstructorName name = parent17 as ConstructorName;
         if (name.name == null) {
           SimpleIdentifier prefix7 = ((typeName as PrefixedIdentifier)).prefix;
           element = nameScope.lookup(prefix7, definingLibrary);
           if (element is PrefixElement) {
             return null;
           } else if (element != null) {
             name.name = ((typeName as PrefixedIdentifier)).identifier;
             name.period = ((typeName as PrefixedIdentifier)).period;
             node.name = prefix7;
             typeName = prefix7;
@@ skipping 147 matching lines @@
   }
   /**
    * The number of type arguments in the given type name does not match the number of parameters in
    * the corresponding class element. Return the error code that should be used to report this
    * error.
    * @param node the type name with the wrong number of type arguments
    * @return the error code that should be used to report that the wrong number of type arguments
    * were provided
    */
   ErrorCode getInvalidTypeParametersErrorCode(TypeName node) {
-    ASTNode parent17 = node.parent;
-    if (parent17 is ConstructorName) {
-      parent17 = parent17.parent;
-      if (parent17 is InstanceCreationExpression) {
-        if (((parent17 as InstanceCreationExpression)).isConst()) {
+    ASTNode parent18 = node.parent;
+    if (parent18 is ConstructorName) {
+      parent18 = parent18.parent;
+      if (parent18 is InstanceCreationExpression) {
+        if (((parent18 as InstanceCreationExpression)).isConst()) {
           return CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS;
         } else {
           return CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS;
         }
       }
     }
     return StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
   }
   /**
    * Given the multiple elements to which a single name could potentially be resolved, return the
@@ skipping 1208 matching lines @@
   Object visitReturnStatement(ReturnStatement node) {
     checkForReturnOfInvalidType(node);
     return super.visitReturnStatement(node);
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     checkForConstFormalParameter(node);
     return super.visitSimpleFormalParameter(node);
   }
   Object visitSwitchStatement(SwitchStatement node) {
     checkForCaseExpressionTypeImplementsEquals(node);
+    checkForInconsistentCaseExpressionTypes(node);
     return super.visitSwitchStatement(node);
   }
   Object visitThrowExpression(ThrowExpression node) {
     checkForConstEvalThrowsException(node);
     return super.visitThrowExpression(node);
   }
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     checkForFinalNotInitialized2(node.variables);
     return super.visitTopLevelVariableDeclaration(node);
   }
@@ skipping 334 matching lines @@
     }
     return false;
   }
   /**
    * This verifies that the passed field formal parameter is in a constructor declaration.
    * @param node the field formal parameter to test
    * @return return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR
    */
   bool checkForFieldInitializerOutsideConstructor(FieldFormalParameter node) {
-    ASTNode parent18 = node.parent;
-    if (parent18 != null) {
-      ASTNode grandparent = parent18.parent;
+    ASTNode parent19 = node.parent;
+    if (parent19 != null) {
+      ASTNode grandparent = parent19.parent;
       if (grandparent != null && grandparent is! ConstructorDeclaration && grandparent.parent is! ConstructorDeclaration) {
         _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, node, []);
         return true;
       }
     }
     return false;
   }
   /**
    * This verifies that final fields that are declared, without any constructors in the enclosing
    * class, are initialized. Cases in which there is at least one constructor are handled at the end
@@ skipping 46 matching lines @@
    * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
    */
   bool checkForImplementsDisallowedClass(ImplementsClause implementsClause) {
     bool foundError = false;
     for (TypeName type in implementsClause.interfaces) {
       foundError = javaBooleanOr(foundError, checkForExtendsOrImplementsDisallowedClass(type, CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS));
     }
     return foundError;
   }
   /**
+   * This verifies that the passed switch statement case expressions all have the same type.
+   * @param node the switch statement to evaluate
+   * @return return {@code true} if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#INCONSISTENT_CASE_EXPRESSION_TYPES
+   */
+  bool checkForInconsistentCaseExpressionTypes(SwitchStatement node) {
+    NodeList<SwitchMember> switchMembers = node.members;
+    bool foundError = false;
+    Type2 firstType = null;
+    for (SwitchMember switchMember in switchMembers) {
+      if (switchMember is SwitchCase) {
+        SwitchCase switchCase = switchMember as SwitchCase;
+        Expression expression17 = switchCase.expression;
+        if (firstType == null) {
+          firstType = expression17.staticType;
+        } else {
+          Type2 nType = expression17.staticType;
+          if (firstType != nType) {
+            _errorReporter.reportError(CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES, expression17, [expression17.toSource(), firstType.name]);
+            foundError = true;
+          }
+        }
+      }
+    }
+    return foundError;
+  }
+  /**
    * This verifies that the passed assignment expression represents a valid assignment.
    * @param node the assignment expression to evaluate
    * @return return {@code true} if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
   bool checkForInvalidAssignment(AssignmentExpression node) {
     Expression lhs = node.leftHandSide;
     Expression rhs = node.rightHandSide;
     VariableElement leftElement = getVariableElement(lhs);
     Type2 leftType = (leftElement == null) ? getType(lhs) : leftElement.type;
@@ skipping 194 matching lines @@
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   bool needsRecompilation() => true;
   int compareTo(ResolverErrorCode other) => __ordinal - other.__ordinal;
   String toString() => __name;
 }