New analyzer_experimental snapshot.

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';
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 599 matching lines @@
     if (element is PropertyInducingElementImpl) {
       PropertyInducingElementImpl variable = element as PropertyInducingElementImpl;
       if (_inFieldContext) {
         ((variable as FieldElementImpl)).static = matches(((node.parent.parent as FieldDeclaration)).staticKeyword, sc.Keyword.STATIC);
       }
       PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(variable);
       getter.getter = true;
       getter.static = variable.isStatic;
       _currentHolder.addAccessor(getter);
       variable.getter = getter;
-      PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(variable);
-      setter.setter = true;
-      setter.static = variable.isStatic;
-      ParameterElementImpl parameter = new ParameterElementImpl.con2("_${variable.name}", variable.nameOffset);
-      parameter.synthetic = true;
-      parameter.parameterKind = ParameterKind.REQUIRED;
-      setter.parameters = <ParameterElement> [parameter];
-      _currentHolder.addAccessor(setter);
-      variable.setter = setter;
+      if (!isFinal) {
+        PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(variable);
+        setter.setter = true;
+        setter.static = variable.isStatic;
+        ParameterElementImpl parameter = new ParameterElementImpl.con2("_${variable.name}", variable.nameOffset);
+        parameter.synthetic = true;
+        parameter.parameterKind = ParameterKind.REQUIRED;
+        setter.parameters = <ParameterElement> [parameter];
+        _currentHolder.addAccessor(setter);
+        variable.setter = setter;
+      }
     }
     return null;
   }
 
   /**
    * Creates the [ConstructorElement]s array with the single default constructor element.
    *
    * @param interfaceType the interface type for which to create a default constructor
    * @return the [ConstructorElement]s array with the single default constructor element
    */
@@ skipping 530 matching lines @@
     try {
       if (isScriptNode(node)) {
         Source htmlSource = _htmlElement.source;
         ht.XmlAttributeNode scriptAttribute = getScriptSourcePath(node);
         String scriptSourcePath = scriptAttribute == null ? null : scriptAttribute.text;
         if (identical(node.attributeEnd.type, ht.TokenType.GT) && scriptSourcePath == null) {
           EmbeddedHtmlScriptElementImpl script = new EmbeddedHtmlScriptElementImpl(node);
           String contents = node.content;
           int attributeEnd = node.attributeEnd.end;
           LineInfo_Location location = _lineInfo.getLocation(attributeEnd);
-          sc.StringScanner scanner = new sc.StringScanner(htmlSource, contents, errorListener);
-          scanner.setSourceStart(location.lineNumber, location.columnNumber, attributeEnd);
+          sc.Scanner scanner = new sc.Scanner(htmlSource, new sc.SubSequenceReader(new CharSequence(contents), attributeEnd), errorListener);
+          scanner.setSourceStart(location.lineNumber, location.columnNumber);
           sc.Token firstToken = scanner.tokenize();
           List<int> lineStarts = scanner.lineStarts;
           Parser parser = new Parser(htmlSource, errorListener);
           CompilationUnit unit = parser.parseCompilationUnit(firstToken);
           try {
             LibraryResolver resolver = new LibraryResolver(_context);
             LibraryElementImpl library = resolver.resolveEmbeddedLibrary(htmlSource, _modificationStamp, unit, true) as LibraryElementImpl;
             script.scriptLibrary = library;
             resolvedLibraries.addAll(resolver.resolvedLibraries);
             errorListener.addAll(resolver.errorListener);
@@ skipping 1765 matching lines @@
    * The type representing the type 'type'.
    */
   Type2 _typeType;
 
   /**
    * A utility class for the resolver to answer the question of "what are my subtypes?".
    */
   SubtypeManager _subtypeManager;
 
   /**
+   * The object keeping track of which elements have had their types promoted.
+   */
+  TypePromotionManager _promoteManager;
+
+  /**
    * The name of the method that can be implemented by a class to allow its instances to be invoked
    * as if they were a function.
    */
   static String CALL_METHOD_NAME = "call";
 
   /**
    * The name of the method that will be invoked if an attempt is made to invoke an undefined method
    * on an object.
    */
   static String NO_SUCH_METHOD_METHOD_NAME = "noSuchMethod";
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param resolver the resolver driving this participant
    */
   ElementResolver(ResolverVisitor resolver) {
     this._resolver = resolver;
     AnalysisOptions options = resolver.definingLibrary.context.analysisOptions;
     _strictMode = options.strictMode;
     _enableHints = options.hint;
     _dynamicType = resolver.typeProvider.dynamicType;
     _typeType = resolver.typeProvider.typeType;
     _subtypeManager = new SubtypeManager();
+    _promoteManager = resolver.promoteManager;
   }
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (operatorType != sc.TokenType.EQ) {
       operatorType = operatorFromCompoundAssignment(operatorType);
       Expression leftHandSide = node.leftHandSide;
       if (leftHandSide != null) {
         String methodName = operatorType.lexeme;
         Type2 staticType = getStaticType(leftHandSide);
         MethodElement staticMethod = lookUpMethod(leftHandSide, staticType, methodName);
         node.staticElement = staticMethod;
         Type2 propagatedType = getPropagatedType(leftHandSide);
         MethodElement propagatedMethod = lookUpMethod(leftHandSide, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
         bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
         bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
         if (shouldReportMissingMember_propagated) {
           if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
             shouldReportMissingMember_propagated = false;
           }
         }
         if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_METHOD : HintCode.UNDEFINED_METHOD) as ErrorCode;
-          _resolver.reportErrorProxyConditionalAnalysisError3(staticType.element, errorCode, operator, [
+          _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
               methodName,
               shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
         }
       }
     }
     return null;
   }
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     if (operator.isUserDefinableOperator) {
       Expression leftOperand = node.leftOperand;
       if (leftOperand != null) {
         String methodName = operator.lexeme;
         Type2 staticType = getStaticType(leftOperand);
         MethodElement staticMethod = lookUpMethod(leftOperand, staticType, methodName);
         node.staticElement = staticMethod;
         Type2 propagatedType = getPropagatedType(leftOperand);
         MethodElement propagatedMethod = lookUpMethod(leftOperand, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
         bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
         bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
         if (shouldReportMissingMember_propagated) {
           if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
             shouldReportMissingMember_propagated = false;
           }
         }
         if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
-          _resolver.reportErrorProxyConditionalAnalysisError3(staticType.element, errorCode, operator, [
+          _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
               methodName,
               shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
         }
       }
     }
     return null;
   }
   Object visitBreakStatement(BreakStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
@@ skipping 399 matching lines @@
     node.propagatedElement = propagatedMethod;
     bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
     bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
     if (shouldReportMissingMember_propagated) {
       if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
         shouldReportMissingMember_propagated = false;
       }
     }
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
       ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
-      _resolver.reportErrorProxyConditionalAnalysisError3(staticType.element, errorCode, node.operator, [
+      _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, node.operator, [
           methodName,
           shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
     }
     return null;
   }
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefix = node.prefix;
     SimpleIdentifier identifier = node.identifier;
     Element prefixElement = prefix.staticElement;
     if (prefixElement is PrefixElement) {
@@ skipping 47 matching lines @@
       node.propagatedElement = propagatedMethod;
       bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
       bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
       if (shouldReportMissingMember_propagated) {
         if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
           shouldReportMissingMember_propagated = false;
         }
       }
       if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
         ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
-        _resolver.reportErrorProxyConditionalAnalysisError3(staticType.element, errorCode, operator, [
+        _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
             methodName,
             shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
       }
     }
     return null;
   }
   Object visitPropertyAccess(PropertyAccess node) {
     Expression target = node.realTarget;
     if (target is SuperExpression && !isSuperInValidContext(target as SuperExpression)) {
       return null;
@@ skipping 61 matching lines @@
       Annotation annotation = node.parent as Annotation;
       resolveAnnotationElement(annotation, element, null);
     }
     return null;
   }
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (enclosingClass == null) {
       return null;
     }
-    ClassElement superclass = getSuperclass(enclosingClass);
-    if (superclass == null) {
+    InterfaceType superType = enclosingClass.supertype;
+    if (superType == null) {
       return null;
     }
     SimpleIdentifier name = node.constructorName;
-    ConstructorElement element;
-    if (name == null) {
-      element = superclass.unnamedConstructor;
-    } else {
-      element = superclass.getNamedConstructor(name.name);
-    }
+    String superName = name != null ? name.name : null;
+    ConstructorElement element = superType.lookUpConstructor(superName, _resolver.definingLibrary);
     if (element == null) {
       if (name != null) {
-        _resolver.reportError5(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER, node, [superclass.name, name]);
+        _resolver.reportError5(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER, node, [superType.displayName, name]);
       } else {
-        _resolver.reportError5(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node, [superclass.name]);
+        _resolver.reportError5(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node, [superType.displayName]);
       }
       return null;
     } else {
       if (element.isFactory) {
         _resolver.reportError5(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
       }
     }
     if (name != null) {
       name.staticElement = element;
     }
@@ skipping 127 matching lines @@
     if (shouldReportMissingMember_propagated) {
       if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
         shouldReportMissingMember_propagated = false;
       }
     }
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
       sc.Token leftBracket = node.leftBracket;
       sc.Token rightBracket = node.rightBracket;
       ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
       if (leftBracket == null || rightBracket == null) {
-        _resolver.reportErrorProxyConditionalAnalysisError(staticType.element, errorCode, node, [
+        _resolver.reportErrorProxyConditionalAnalysisError(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, node, [
             methodName,
             shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
       } else {
         int offset = leftBracket.offset;
         int length = rightBracket.offset - offset + 1;
-        _resolver.reportErrorProxyConditionalAnalysisError2(staticType.element, errorCode, offset, length, [
+        _resolver.reportErrorProxyConditionalAnalysisError2(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, offset, length, [
             methodName,
             shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
       }
       return true;
     }
     return false;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
@@ skipping 18 matching lines @@
           Element functionElement = ((getterReturnType as FunctionType)).element;
           if (functionElement is ExecutableElement) {
             return resolveArgumentsToParameters(false, argumentList, functionElement as ExecutableElement);
           }
         }
       }
     } else if (element is ExecutableElement) {
       return resolveArgumentsToParameters(false, argumentList, element as ExecutableElement);
     } else if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
-      Type2 type = variable.type;
+      Type2 type = _promoteManager.getStaticType(variable);
       if (type is FunctionType) {
         FunctionType functionType = type as FunctionType;
         List<ParameterElement> parameters = functionType.parameters;
         return resolveArgumentsToParameters2(false, argumentList, parameters);
       } else if (type is InterfaceType) {
         MethodElement callMethod = ((type as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
         if (callMethod != null) {
           List<ParameterElement> parameters = callMethod.parameters;
           return resolveArgumentsToParameters2(false, argumentList, parameters);
         }
@@ skipping 97 matching lines @@
       return _resolver.typeProvider.bottomType;
     }
     Type2 staticType = resolveTypeParameter(expression.staticType);
     if (staticType is FunctionType) {
       staticType = _resolver.typeProvider.functionType;
     }
     return staticType;
   }
 
   /**
-   * Return the element representing the superclass of the given class.
-   *
-   * @param targetClass the class whose superclass is to be returned
-   * @return the element representing the superclass of the given class
-   */
-  ClassElement getSuperclass(ClassElement targetClass) {
-    InterfaceType superType = targetClass.supertype;
-    if (superType == null) {
-      return null;
-    }
-    return superType.element;
-  }
-
-  /**
    * Return `true` if the given type represents an object that could be invoked using the call
    * operator '()'.
    *
    * @param type the type being tested
    * @return `true` if the given type represents an object that could be invoked
    */
   bool isExecutableType(Type2 type) {
     if (type.isDynamic || (type is FunctionType) || type.isDartCoreFunction || type.isObject) {
       return true;
     } else if (type is InterfaceType) {
@@ skipping 705 matching lines @@
     ExecutableElement propagatedElement = resolveProperty(target, propagatedType, propertyName);
     propertyName.propagatedElement = propagatedElement;
     bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticElement) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedElement));
     bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedElement) : false;
     if (shouldReportMissingMember_propagated) {
       if (memberFoundInSubclass(propagatedType.element, propertyName.name, false, true)) {
         shouldReportMissingMember_propagated = false;
       }
     }
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
-      Element selectedElement = select(staticElement, propagatedElement);
-      bool isStaticProperty = isStatic(selectedElement);
+      Element staticOrPropagatedEnclosingElt = shouldReportMissingMember_static ? staticType.element : propagatedType.element;
+      bool isStaticProperty = isStatic(staticOrPropagatedEnclosingElt);
       if (propertyName.inSetterContext()) {
         if (isStaticProperty) {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticWarningCode.UNDEFINED_SETTER : HintCode.UNDEFINED_SETTER) as ErrorCode;
-          _resolver.reportErrorProxyConditionalAnalysisError(staticType.element, errorCode, propertyName, [
+          _resolver.reportErrorProxyConditionalAnalysisError(staticOrPropagatedEnclosingElt, errorCode, propertyName, [
               propertyName.name,
-              shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
+              staticOrPropagatedEnclosingElt.displayName]);
         } else {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_SETTER : HintCode.UNDEFINED_SETTER) as ErrorCode;
-          _resolver.reportErrorProxyConditionalAnalysisError(staticType.element, errorCode, propertyName, [
+          _resolver.reportErrorProxyConditionalAnalysisError(staticOrPropagatedEnclosingElt, errorCode, propertyName, [
               propertyName.name,
-              shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
+              staticOrPropagatedEnclosingElt.displayName]);
         }
       } else if (propertyName.inGetterContext()) {
         if (isStaticProperty) {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticWarningCode.UNDEFINED_GETTER : HintCode.UNDEFINED_GETTER) as ErrorCode;
-          _resolver.reportErrorProxyConditionalAnalysisError(staticType.element, errorCode, propertyName, [
+          _resolver.reportErrorProxyConditionalAnalysisError(staticOrPropagatedEnclosingElt, errorCode, propertyName, [
               propertyName.name,
-              shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
+              staticOrPropagatedEnclosingElt.displayName]);
         } else {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_GETTER : HintCode.UNDEFINED_GETTER) as ErrorCode;
-          _resolver.reportErrorProxyConditionalAnalysisError(staticType.element, errorCode, propertyName, [
+          _resolver.reportErrorProxyConditionalAnalysisError(staticOrPropagatedEnclosingElt, errorCode, propertyName, [
               propertyName.name,
-              shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
+              staticOrPropagatedEnclosingElt.displayName]);
         }
       } else {
-        _resolver.reportErrorProxyConditionalAnalysisError(staticType.element, StaticWarningCode.UNDEFINED_IDENTIFIER, propertyName, [propertyName.name]);
+        _resolver.reportErrorProxyConditionalAnalysisError(staticOrPropagatedEnclosingElt, StaticWarningCode.UNDEFINED_IDENTIFIER, propertyName, [propertyName.name]);
       }
     }
   }
 
   /**
    * Resolve the given simple identifier if possible. Return the element to which it could be
    * resolved, or `null` if it could not be resolved. This does not record the results of the
    * resolution.
    *
    * @param node the identifier to be resolved
@@ skipping 1723 matching lines @@
    * Resolve the identifiers and perform type analysis in the given library.
    *
    * @param library the library to be resolved
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    *           the library cannot be analyzed
    */
   void resolveReferencesAndTypes2(Library library) {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     try {
       for (Source source in library.compilationUnitSources) {
+        CompilationUnit ast = library.getAST(source);
+        ast.accept(new VariableResolverVisitor(library, source, _typeProvider));
         ResolverVisitor visitor = new ResolverVisitor.con1(library, source, _typeProvider);
-        library.getAST(source).accept(visitor);
+        ast.accept(visitor);
         for (ProxyConditionalAnalysisError conditionalCode in visitor.proxyConditionalAnalysisErrors) {
           if (conditionalCode.shouldIncludeErrorCode()) {
             visitor.reportError(conditionalCode.analysisError);
           }
         }
       }
     } finally {
       timeCounter.stop();
     }
   }
@@ skipping 270 matching lines @@
    * current node is not contained in a function.
    */
   ExecutableElement enclosingFunction = null;
 
   /**
    * The object keeping track of which elements have had their types overridden.
    */
   final TypeOverrideManager overrideManager = new TypeOverrideManager();
 
   /**
+   * The object keeping track of which elements have had their types promoted.
+   */
+  final TypePromotionManager promoteManager = new TypePromotionManager();
+
+  /**
    * Proxy conditional error codes.
    */
   final List<ProxyConditionalAnalysisError> proxyConditionalAnalysisErrors = new List<ProxyConditionalAnalysisError>();
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
@@ skipping 31 matching lines @@
   }
   Object visitBinaryExpression(BinaryExpression node) {
     sc.TokenType operatorType = node.operator.type;
     Expression leftOperand = node.leftOperand;
     Expression rightOperand = node.rightOperand;
     if (identical(operatorType, sc.TokenType.AMPERSAND_AMPERSAND)) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         try {
           overrideManager.enterScope();
+          promoteManager.enterScope();
           propagateTrueState(leftOperand);
+          promoteTypes(leftOperand);
+          clearTypePromotionsIfPotentiallyMutatedIn(leftOperand);
+          clearTypePromotionsIfPotentiallyMutatedIn(rightOperand);
+          clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(rightOperand);
           rightOperand.accept(this);
         } finally {
           overrideManager.exitScope();
+          promoteManager.exitScope();
         }
       }
     } else if (identical(operatorType, sc.TokenType.BAR_BAR)) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         try {
           overrideManager.enterScope();
           propagateFalseState(leftOperand);
           rightOperand.accept(this);
         } finally {
@@ skipping 63 matching lines @@
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Expression thenExpression = node.thenExpression;
     if (thenExpression != null) {
       try {
         overrideManager.enterScope();
+        promoteManager.enterScope();
         propagateTrueState(condition);
+        promoteTypes(condition);
+        clearTypePromotionsIfPotentiallyMutatedIn(thenExpression);
+        clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(thenExpression);
         thenExpression.accept(this);
       } finally {
         overrideManager.exitScope();
+        promoteManager.exitScope();
       }
     }
     Expression elseExpression = node.elseExpression;
     if (elseExpression != null) {
       try {
         overrideManager.enterScope();
         propagateFalseState(condition);
         elseExpression.accept(this);
       } finally {
         overrideManager.exitScope();
@@ skipping 118 matching lines @@
   }
   Object visitHideCombinator(HideCombinator node) => null;
   Object visitIfStatement(IfStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Map<Element, Type2> thenOverrides = null;
     Statement thenStatement = node.thenStatement;
     if (thenStatement != null) {
       try {
         overrideManager.enterScope();
+        promoteManager.enterScope();
         propagateTrueState(condition);
+        promoteTypes(condition);
+        clearTypePromotionsIfPotentiallyMutatedIn(thenStatement);
+        clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(thenStatement);
         visitStatementInScope(thenStatement);
       } finally {
         thenOverrides = overrideManager.captureLocalOverrides();
         overrideManager.exitScope();
+        promoteManager.exitScope();
       }
     }
     Map<Element, Type2> elseOverrides = null;
     Statement elseStatement = node.elseStatement;
     if (elseStatement != null) {
       try {
         overrideManager.enterScope();
         propagateFalseState(condition);
         visitStatementInScope(elseStatement);
       } finally {
@@ skipping 155 matching lines @@
     } else if (expression is PropertyAccess) {
       element = ((expression as PropertyAccess)).propertyName.staticElement;
     }
     if (element is VariableElement) {
       return element as VariableElement;
     }
     return null;
   }
 
   /**
+   * Return the static element associated with the given expression whose type can be promoted, or
+   * `null` if there is no element whose type can be promoted.
+   *
+   * @param expression the expression with which the element is associated
+   * @return the element associated with the given expression
+   */
+  VariableElement getPromotionStaticElement(Expression expression) {
+    if (expression is! SimpleIdentifier) {
+      return null;
+    }
+    SimpleIdentifier identifier = expression as SimpleIdentifier;
+    Element element = identifier.staticElement;
+    if (element is! VariableElement) {
+      return null;
+    }
+    ElementKind kind = element.kind;
+    if (identical(kind, ElementKind.LOCAL_VARIABLE)) {
+      return element as VariableElement;
+    }
+    if (identical(kind, ElementKind.PARAMETER)) {
+      return element as VariableElement;
+    }
+    return null;
+  }
+
+  /**
    * If it is appropriate to do so, override the current type of the static and propagated elements
    * associated with the given expression with the given type. Generally speaking, it is appropriate
    * if the given type is more specific than the current type.
    *
    * @param expression the expression used to access the static and propagated elements whose types
    *          might be overridden
    * @param potentialType the potential type of the elements
    */
   void override(Expression expression, Type2 potentialType) {
     VariableElement element = getOverridableStaticElement(expression);
@@ skipping 24 matching lines @@
         return;
       }
     }
     Type2 currentType = getBestType(element);
     if (currentType == null || !currentType.isMoreSpecificThan(potentialType)) {
       overrideManager.setType(element, potentialType);
     }
   }
 
   /**
+   * If it is appropriate to do so, promotes the current type of the static element associated with
+   * the given expression with the given type. Generally speaking, it is appropriate if the given
+   * type is more specific than the current type.
+   *
+   * @param expression the expression used to access the static element whose types might be
+   *          promoted
+   * @param potentialType the potential type of the elements
+   */
+  void promote(Expression expression, Type2 potentialType) {
+    VariableElement element = getPromotionStaticElement(expression);
+    if (element != null) {
+      Type2 type = expression.staticType;
+      if (type == null || type.isDynamic) {
+        return;
+      }
+      if (potentialType == null || potentialType.isDynamic) {
+        return;
+      }
+      if (!potentialType.isMoreSpecificThan(type)) {
+        return;
+      }
+      promoteManager.setType(element, potentialType);
+    }
+  }
+
+  /**
    * Report a conditional analysis error with the given error code and arguments.
    *
    * @param enclosingElement the enclosing element
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorProxyConditionalAnalysisError(Element enclosingElement, ErrorCode errorCode, ASTNode node, List<Object> arguments) {
     proxyConditionalAnalysisErrors.add(new ProxyConditionalAnalysisError(enclosingElement, new AnalysisError.con2(source, node.offset, node.length, errorCode, arguments)));
   }
@@ skipping 64 matching lines @@
     try {
       propagateTrueState(node.condition);
       visitStatementInScope(node.body);
       node.updaters.accept(this);
     } finally {
       overrideManager.exitScope();
     }
   }
 
   /**
+   * Checks each promoted variable in the current scope for compliance with the following
+   * specification statement:
+   *
+   * If the variable <i>v</i> is accessed by a closure in <i>s<sub>1</sub></i> then the variable
+   * <i>v</i> is not potentially mutated anywhere in the scope of <i>v</i>.
+   */
+  void clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(ASTNode target) {
+    for (Element element in promoteManager.promotedElements) {
+      if (((element as VariableElementImpl)).isPotentiallyMutated) {
+        if (isVariableAccessedInClosure(element, target)) {
+          promoteManager.setType(element, null);
+        }
+      }
+    }
+  }
+
+  /**
+   * Checks each promoted variable in the current scope for compliance with the following
+   * specification statement:
+   *
+   * <i>v</i> is not potentially mutated in <i>s<sub>1</sub></i> or within a closure.
+   */
+  void clearTypePromotionsIfPotentiallyMutatedIn(ASTNode target) {
+    for (Element element in promoteManager.promotedElements) {
+      if (isVariablePotentiallyMutatedIn(element, target)) {
+        promoteManager.setType(element, null);
+      }
+    }
+  }
+
+  /**
    * Return the best type information available for the given element. If the type of the element
    * has been overridden, then return the overriding type. Otherwise, return the static type.
    *
    * @param element the element for which type information is to be returned
    * @return the best type information available for the given element
    */
   Type2 getBestType(Element element) {
     Type2 bestType = overrideManager.getType(element);
     if (bestType == null) {
       if (element is LocalVariableElement) {
@@ skipping 107 matching lines @@
       int size = statements.length;
       if (size == 0) {
         return false;
       }
       return isAbruptTermination2(statements[size - 1]);
     }
     return false;
   }
 
   /**
+   * Return `true` if the given variable is accessed within a closure in the given
+   * [ASTNode] and also mutated somewhere in variable scope. This information is only
+   * available for local variables (including parameters).
+   *
+   * @param variable the variable to check
+   * @param target the [ASTNode] to check within
+   * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
+   */
+  bool isVariableAccessedInClosure(Element variable, ASTNode target) {
+    List<bool> result = [false];
+    target.accept(new RecursiveASTVisitor_7(result, variable));
+    return result[0];
+  }
+
+  /**
+   * Return `true` if the given variable is potentially mutated somewhere in the given
+   * [ASTNode]. This information is only available for local variables (including parameters).
+   *
+   * @param variable the variable to check
+   * @param target the [ASTNode] to check within
+   * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
+   */
+  bool isVariablePotentiallyMutatedIn(Element variable, ASTNode target) {
+    List<bool> result = [false];
+    target.accept(new RecursiveASTVisitor_8(result, variable));
+    return result[0];
+  }
+
+  /**
+   * Promotes type information using given condition.
+   */
+  void promoteTypes(Expression condition) {
+    if (condition is BinaryExpression) {
+      BinaryExpression binary = condition as BinaryExpression;
+      if (identical(binary.operator.type, sc.TokenType.AMPERSAND_AMPERSAND)) {
+        Expression left = binary.leftOperand;
+        Expression right = binary.rightOperand;
+        promoteTypes(left);
+        promoteTypes(right);
+        clearTypePromotionsIfPotentiallyMutatedIn(right);
+      }
+    } else if (condition is IsExpression) {
+      IsExpression is2 = condition as IsExpression;
+      if (is2.notOperator == null) {
+        promote(is2.expression, is2.type.type);
+      }
+    } else if (condition is ParenthesizedExpression) {
+      promoteTypes(((condition as ParenthesizedExpression)).expression);
+    }
+  }
+
+  /**
    * Propagate any type information that results from knowing that the given condition will have
    * been evaluated to 'false'.
    *
    * @param condition the condition that will have evaluated to 'false'
    */
   void propagateFalseState(Expression condition) {
     if (condition is BinaryExpression) {
       BinaryExpression binary = condition as BinaryExpression;
       if (identical(binary.operator.type, sc.TokenType.BAR_BAR)) {
         propagateFalseState(binary.leftOperand);
@@ skipping 66 matching lines @@
   set elementResolver_J2DAccessor(__v) => _elementResolver = __v;
   get labelScope_J2DAccessor => labelScope;
   set labelScope_J2DAccessor(__v) => labelScope = __v;
   get nameScope_J2DAccessor => nameScope;
   set nameScope_J2DAccessor(__v) => nameScope = __v;
   get typeAnalyzer_J2DAccessor => _typeAnalyzer;
   set typeAnalyzer_J2DAccessor(__v) => _typeAnalyzer = __v;
   get enclosingClass_J2DAccessor => enclosingClass;
   set enclosingClass_J2DAccessor(__v) => enclosingClass = __v;
 }
+class RecursiveASTVisitor_7 extends RecursiveASTVisitor<Object> {
+  List<bool> result;
+  Element variable;
+  RecursiveASTVisitor_7(this.result, this.variable) : super();
+  bool _inClosure = false;
+  Object visitFunctionExpression(FunctionExpression node) {
+    bool inClosure = this._inClosure;
+    try {
+      this._inClosure = true;
+      return super.visitFunctionExpression(node);
+    } finally {
+      this._inClosure = inClosure;
+    }
+  }
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    if (result[0]) {
+      return null;
+    }
+    if (_inClosure && identical(node.staticElement, variable)) {
+      result[0] = javaBooleanOr(result[0], true);
+    }
+    return null;
+  }
+}
+class RecursiveASTVisitor_8 extends RecursiveASTVisitor<Object> {
+  List<bool> result;
+  Element variable;
+  RecursiveASTVisitor_8(this.result, this.variable) : super();
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    if (result[0]) {
+      return null;
+    }
+    if (identical(node.staticElement, variable)) {
+      if (node.inSetterContext()) {
+        result[0] = javaBooleanOr(result[0], true);
+      }
+    }
+    return null;
+  }
+}
 /**
  * The abstract class `ScopedVisitor` maintains name and label scopes as an AST structure is
  * being visited.
  *
  * @coverage dart.engine.resolver
  */
 abstract class ScopedVisitor extends UnifyingASTVisitor<Object> {
 
   /**
    * The element for the library containing the compilation unit being visited.
@@ skipping 547 matching lines @@
    * nodes are not within a class.
    */
   InterfaceType _thisType;
 
   /**
    * The object keeping track of which elements have had their types overridden.
    */
   TypeOverrideManager _overrideManager;
 
   /**
+   * The object keeping track of which elements have had their types promoted.
+   */
+  TypePromotionManager _promoteManager;
+
+  /**
    * A table mapping [ExecutableElement]s to their propagated return types.
    */
   Map<ExecutableElement, Type2> _propagatedReturnTypes = new Map<ExecutableElement, Type2>();
 
   /**
    * A table mapping HTML tag names to the names of the classes (in 'dart:html') that implement
    * those tags.
    */
   static Map<String, String> _HTML_ELEMENT_TO_CLASS_MAP = createHtmlTagToClassMap();
 
   /**
    * Initialize a newly created type analyzer.
    *
    * @param resolver the resolver driving this participant
    */
   StaticTypeAnalyzer(ResolverVisitor resolver) {
     this._resolver = resolver;
     _typeProvider = resolver.typeProvider;
     _dynamicType = _typeProvider.dynamicType;
     _overrideManager = resolver.overrideManager;
+    _promoteManager = resolver.promoteManager;
   }
 
   /**
    * Set the type of the class being analyzed to the given type.
    *
    * @param thisType the type representing the class containing the nodes being analyzed
    */
   void set thisType(InterfaceType thisType) {
     this._thisType = thisType;
   }
@@ skipping 926 matching lines @@
       staticType = ((element as FunctionTypeAliasElement)).type;
     } else if (element is MethodElement) {
       staticType = ((element as MethodElement)).type;
     } else if (element is PropertyAccessorElement) {
       staticType = getType(element as PropertyAccessorElement, null);
     } else if (element is ExecutableElement) {
       staticType = ((element as ExecutableElement)).type;
     } else if (element is TypeParameterElement) {
       staticType = ((element as TypeParameterElement)).type;
     } else if (element is VariableElement) {
-      staticType = ((element as VariableElement)).type;
+      VariableElement variable = element as VariableElement;
+      staticType = _promoteManager.getStaticType(variable);
     } else if (element is PrefixElement) {
       return null;
     } else {
       staticType = _dynamicType;
     }
     recordStaticType(node, staticType);
     Type2 propagatedType = _overrideManager.getType(element);
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
       recordPropagatedType2(node, propagatedType);
     }
@@ skipping 102 matching lines @@
    * @param body the boy of the function whose propagated return type is to be computed
    * @return the propagated return type that was computed
    */
   Type2 computePropagatedReturnType2(FunctionBody body) {
     if (body is ExpressionFunctionBody) {
       ExpressionFunctionBody expressionBody = body as ExpressionFunctionBody;
       return expressionBody.expression.bestType;
     }
     if (body is BlockFunctionBody) {
       List<Type2> result = [null];
-      body.accept(new GeneralizingASTVisitor_7(result));
+      body.accept(new GeneralizingASTVisitor_9(result));
       return result[0];
     }
     return null;
   }
 
   /**
    * Compute the static return type of the method or function represented by the given element.
    *
    * @param element the element representing the method or function invoked by the given node
    * @return the static return type that was computed
@@ skipping 19 matching lines @@
         if (returnType != null) {
           return returnType;
         }
       }
     } else if (element is ExecutableElement) {
       FunctionType type = ((element as ExecutableElement)).type;
       if (type != null) {
         return type.returnType;
       }
     } else if (element is VariableElement) {
-      Type2 variableType = ((element as VariableElement)).type;
+      VariableElement variable = element as VariableElement;
+      Type2 variableType = _promoteManager.getStaticType(variable);
       if (variableType is FunctionType) {
         return ((variableType as FunctionType)).returnType;
       }
     }
     return _dynamicType;
   }
 
   /**
    * Given a function declaration, compute the return static type of the function. The return type
    * of functions with a block body is `dynamicType`, with an expression body it is the type
@@ skipping 298 matching lines @@
         if (getStaticType(node.rightOperand) == intType) {
           staticType = intType;
         }
       }
     }
     return staticType;
   }
   get thisType_J2DAccessor => _thisType;
   set thisType_J2DAccessor(__v) => _thisType = __v;
 }
-class GeneralizingASTVisitor_7 extends GeneralizingASTVisitor<Object> {
+class GeneralizingASTVisitor_9 extends GeneralizingASTVisitor<Object> {
   List<Type2> result;
-  GeneralizingASTVisitor_7(this.result) : super();
+  GeneralizingASTVisitor_9(this.result) : super();
   Object visitExpression(Expression node) => null;
   Object visitReturnStatement(ReturnStatement node) {
     Type2 type;
     Expression expression = node.expression;
     if (expression != null) {
       type = expression.bestType;
     } else {
       type = BottomTypeImpl.instance;
     }
     if (result[0] == null) {
@@ skipping 338 matching lines @@
    * Set the overridden type of the given element to the given type
    *
    * @param element the element whose type might have been overridden
    * @param type the overridden type of the given element
    */
   void setType(Element element, Type2 type) {
     _overridenTypes[element] = type;
   }
 }
 /**
+ * Instances of the class `TypePromotionManager` manage the ability to promote types of local
+ * variables and formal parameters from their declared types based on control flow.
+ */
+class TypePromotionManager {
+
+  /**
+   * The current promotion scope, or `null` if no scope has been entered.
+   */
+  TypePromotionManager_TypePromoteScope _currentScope;
+
+  /**
+   * Enter a new promotions scope.
+   */
+  void enterScope() {
+    _currentScope = new TypePromotionManager_TypePromoteScope(_currentScope);
+  }
+
+  /**
+   * Exit the current promotion scope.
+   */
+  void exitScope() {
+    if (_currentScope == null) {
+      throw new IllegalStateException("No scope to exit");
+    }
+    _currentScope = _currentScope._outerScope;
+  }
+
+  /**
+   * Returns the elements with promoted types.
+   */
+  Iterable<Element> get promotedElements => _currentScope.promotedElements;
+
+  /**
+   * Returns static type of the given variable - declared or promoted.
+   *
+   * @return the static type of the given variable - declared or promoted
+   */
+  Type2 getStaticType(VariableElement variable) {
+    Type2 staticType = getType(variable);
+    if (staticType == null) {
+      staticType = variable.type;
+    }
+    return staticType;
+  }
+
+  /**
+   * Return the promoted type of the given element, or `null` if the type of the element has
+   * not been promoted.
+   *
+   * @param element the element whose type might have been promoted
+   * @return the promoted type of the given element
+   */
+  Type2 getType(Element element) {
+    if (_currentScope == null) {
+      return null;
+    }
+    return _currentScope.getType(element);
+  }
+
+  /**
+   * Set the promoted type of the given element to the given type.
+   *
+   * @param element the element whose type might have been promoted
+   * @param type the promoted type of the given element
+   */
+  void setType(Element element, Type2 type) {
+    if (_currentScope == null) {
+      throw new IllegalStateException("Cannot promote without a scope");
+    }
+    _currentScope.setType(element, type);
+  }
+}
+/**
+ * Instances of the class `TypePromoteScope` represent a scope in which the types of
+ * elements can be promoted.
+ */
+class TypePromotionManager_TypePromoteScope {
+
+  /**
+   * The outer scope in which types might be promoter.
+   */
+  TypePromotionManager_TypePromoteScope _outerScope;
+
+  /**
+   * A table mapping elements to the promoted type of that element.
+   */
+  Map<Element, Type2> _promotedTypes = new Map<Element, Type2>();
+
+  /**
+   * Initialize a newly created scope to be an empty child of the given scope.
+   *
+   * @param outerScope the outer scope in which types might be promoted
+   */
+  TypePromotionManager_TypePromoteScope(TypePromotionManager_TypePromoteScope outerScope) {
+    this._outerScope = outerScope;
+  }
+
+  /**
+   * Returns the elements with promoted types.
+   */
+  Iterable<Element> get promotedElements => _promotedTypes.keys.toSet();
+
+  /**
+   * Return the promoted type of the given element, or `null` if the type of the element has
+   * not been promoted.
+   *
+   * @param element the element whose type might have been promoted
+   * @return the promoted type of the given element
+   */
+  Type2 getType(Element element) {
+    Type2 type = _promotedTypes[element];
+    if (type == null && element is PropertyAccessorElement) {
+      type = _promotedTypes[((element as PropertyAccessorElement)).variable];
+    }
+    if (type != null) {
+      return type;
+    } else if (_outerScope != null) {
+      return _outerScope.getType(element);
+    }
+    return null;
+  }
+
+  /**
+   * Set the promoted type of the given element to the given type.
+   *
+   * @param element the element whose type might have been promoted
+   * @param type the promoted type of the given element
+   */
+  void setType(Element element, Type2 type) {
+    _promotedTypes[element] = type;
+  }
+}
+/**
  * The interface `TypeProvider` defines the behavior of objects that provide access to types
  * defined by the language.
  *
  * @coverage dart.engine.resolver
  */
 abstract class TypeProvider {
 
   /**
    * Return the type representing the built-in type 'Null'.
    *
@@ skipping 316 matching lines @@
   TypeResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) : super.con2(definingLibrary, source, typeProvider, errorListener) {
     _dynamicType = typeProvider.dynamicType;
   }
   Object visitCatchClause(CatchClause node) {
     super.visitCatchClause(node);
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       TypeName exceptionTypeName = node.exceptionType;
       Type2 exceptionType;
       if (exceptionTypeName == null) {
-        exceptionType = typeProvider.objectType;
+        exceptionType = typeProvider.dynamicType;
       } else {
         exceptionType = getType3(exceptionTypeName);
       }
       recordType(exception, exceptionType);
       Element element = exception.staticElement;
       if (element is VariableElementImpl) {
         ((element as VariableElementImpl)).type = exceptionType;
       } else {
       }
     }
@@ skipping 761 matching lines @@
         aliasElement.typeParameters = alias.typeParameters;
         type.typeArguments = alias.type.typeArguments;
       } else {
         type.typeArguments = TypeImpl.EMPTY_ARRAY;
       }
     }
     element.type = type;
   }
 }
 /**
+ * Instances of the class `VariableResolverVisitor` are used to resolve
+ * [SimpleIdentifier]s to local variables and formal parameters.
+ *
+ * @coverage dart.engine.resolver
+ */
+class VariableResolverVisitor extends ScopedVisitor {
+
+  /**
+   * Initialize a newly created visitor to resolve the nodes in a compilation unit.
+   *
+   * @param library the library containing the compilation unit being resolved
+   * @param source the source representing the compilation unit being visited
+   * @param typeProvider the object used to access the types from the core library
+   */
+  VariableResolverVisitor(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider);
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    if (node.staticElement != null) {
+      return null;
+    }
+    ASTNode parent = node.parent;
+    if (parent is PrefixedIdentifier && identical(((parent as PrefixedIdentifier)).identifier, node)) {
+      return null;
+    }
+    if (parent is PropertyAccess && identical(((parent as PropertyAccess)).propertyName, node)) {
+      return null;
+    }
+    if (parent is MethodInvocation && identical(((parent as MethodInvocation)).methodName, node)) {
+      return null;
+    }
+    if (parent is ConstructorName) {
+      return null;
+    }
+    if (parent is Label) {
+      return null;
+    }
+    Element element = nameScope.lookup(node, definingLibrary);
+    if (element is! VariableElement) {
+      return null;
+    }
+    ElementKind kind = element.kind;
+    if (identical(kind, ElementKind.LOCAL_VARIABLE)) {
+      node.staticElement = element;
+      if (node.inSetterContext()) {
+        ((element as LocalVariableElementImpl)).markPotentiallyMutated();
+      }
+    } else if (identical(kind, ElementKind.PARAMETER)) {
+      node.staticElement = element;
+      if (node.inSetterContext()) {
+        ((element as ParameterElementImpl)).markPotentiallyMutated();
+      }
+    }
+    return null;
+  }
+}
+/**
  * Instances of the class `ClassScope` implement the scope defined by a class.
  *
  * @coverage dart.engine.resolver
  */
 class ClassScope extends EnclosedScope {
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
@@ skipping 84 matching lines @@
         javaSetAdd(_hiddenNames, name);
       }
     }
   }
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element element = localLookup(name, referencingLibrary);
     if (element != null) {
       return element;
     }
     if (_hiddenNames.contains(name)) {
-      return null;
+      errorListener.onError(new AnalysisError.con2(source, identifier.offset, identifier.length, CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION, []));
     }
     return enclosingScope.lookup3(identifier, name, referencingLibrary);
   }
 }
 /**
  * Instances of the class `FunctionScope` implement the scope defined by a function.
  *
  * @coverage dart.engine.resolver
  */
 class FunctionScope extends EnclosedScope {
@@ skipping 1082 matching lines @@
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param expression the expression to validate
    */
   void validateInitializerExpression(List<ParameterElement> parameterElements, Expression expression) {
-    EvaluationResultImpl result = expression.accept(new ConstantVisitor_11(this, parameterElements));
+    EvaluationResultImpl result = expression.accept(new ConstantVisitor_13(this, parameterElements));
     reportErrors(result, CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER);
   }
 
   /**
    * Validates that all of the arguments of a constructor initializer are compile time constants.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param argumentList the argument list to validate
    */
@@ skipping 24 matching lines @@
         RedirectingConstructorInvocation invocation = initializer as RedirectingConstructorInvocation;
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation invocation = initializer as SuperConstructorInvocation;
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
     }
   }
 }
-class ConstantVisitor_11 extends ConstantVisitor {
+class ConstantVisitor_13 extends ConstantVisitor {
   final ConstantVerifier ConstantVerifier_this;
   List<ParameterElement> parameterElements;
-  ConstantVisitor_11(this.ConstantVerifier_this, this.parameterElements) : super();
+  ConstantVisitor_13(this.ConstantVerifier_this, this.parameterElements) : super();
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
         Type2 type = parameterElement.type;
         if (type != null) {
           if (type.isDynamic) {
             return ValidResult.RESULT_DYNAMIC;
           }
           if (type.isSubtypeOf(ConstantVerifier_this._boolType)) {
@@ skipping 150 matching lines @@
    */
   ClassElement _enclosingClass;
 
   /**
    * The method or function that we are currently visiting, or `null` if we are not inside a
    * method or function.
    */
   ExecutableElement _enclosingFunction;
 
   /**
+   * The number of return statements found in the method or function that we are currently visiting
+   * that have a return value.
+   */
+  int _returnWithCount = 0;
+
+  /**
+   * The number of return statements found in the method or function that we are currently visiting
+   * that do not have a return value.
+   */
+  int _returnWithoutCount = 0;
+
+  /**
    * This map is initialized when visiting the contents of a class declaration. If the visitor is
    * not in an enclosing class declaration, then the map is set to `null`.
    *
    * When set the map maps the set of [FieldElement]s in the class to an
    * [INIT_STATE#NOT_INIT] or [INIT_STATE#INIT_IN_DECLARATION]. <code>checkFor*</code>
    * methods, specifically [checkForAllFinalInitializedErrorCodes],
    * can make a copy of the map to compute error code states. <code>checkFor*</code> methods should
    * only ever make a copy, or read from this map after it has been set in
    * [visitClassDeclaration].
    *
@@ skipping 71 matching lines @@
       checkForInvalidAssignment(node);
     }
     checkForAssignmentToFinal(node);
     checkForArgumentTypeNotAssignable2(node.rightHandSide);
     return super.visitAssignmentExpression(node);
   }
   Object visitBinaryExpression(BinaryExpression node) {
     checkForArgumentTypeNotAssignable2(node.rightOperand);
     return super.visitBinaryExpression(node);
   }
+  Object visitBlockFunctionBody(BlockFunctionBody node) {
+    int previousReturnWithCount = _returnWithCount;
+    int previousReturnWithoutCount = _returnWithoutCount;
+    try {
+      _returnWithCount = 0;
+      _returnWithoutCount = 0;
+      super.visitBlockFunctionBody(node);
+      checkForMixedReturns(node);
+    } finally {
+      _returnWithCount = previousReturnWithCount;
+      _returnWithoutCount = previousReturnWithoutCount;
+    }
+    return null;
+  }
   Object visitCatchClause(CatchClause node) {
     bool previousIsInCatchClause = _isInCatchClause;
     try {
       _isInCatchClause = true;
       return super.visitCatchClause(node);
     } finally {
       _isInCatchClause = previousIsInCatchClause;
     }
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       _isInNativeClass = node.nativeClause != null;
       _enclosingClass = node.element;
       WithClause withClause = node.withClause;
       ImplementsClause implementsClause = node.implementsClause;
       ExtendsClause extendsClause = node.extendsClause;
       checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
       checkForMemberWithClassName();
       checkForNoDefaultSuperConstructorImplicit(node);
       checkForAllMixinErrorCodes(withClause);
       checkForConflictingTypeVariableErrorCodes(node);
       if (implementsClause != null || extendsClause != null) {
         if (!checkForImplementsDisallowedClass(implementsClause) && !checkForExtendsDisallowedClass(extendsClause)) {
           checkForNonAbstractClassInheritsAbstractMember(node);
           checkForInconsistentMethodInheritance();
-          checkForRecursiveInterfaceInheritance(_enclosingClass, new List<ClassElement>());
+          checkForRecursiveInterfaceInheritance(_enclosingClass);
         }
       }
       ClassElement classElement = node.element;
       if (classElement != null) {
         List<FieldElement> fieldElements = classElement.fields;
         _initialFieldElementsMap = new Map<FieldElement, INIT_STATE>();
         for (FieldElement fieldElement in fieldElements) {
           if (!fieldElement.isSynthetic) {
             _initialFieldElementsMap[fieldElement] = fieldElement.initializer == null ? INIT_STATE.NOT_INIT : INIT_STATE.INIT_IN_DECLARATION;
           }
@@ skipping 10 matching lines @@
       _initialFieldElementsMap = null;
       _enclosingClass = outerClass;
     }
   }
   Object visitClassTypeAlias(ClassTypeAlias node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     checkForAllMixinErrorCodes(node.withClause);
     ClassElement outerClassElement = _enclosingClass;
     try {
       _enclosingClass = node.element;
-      checkForRecursiveInterfaceInheritance(node.element, new List<ClassElement>());
+      checkForRecursiveInterfaceInheritance(node.element);
       checkForTypeAliasCannotReferenceItself_mixin(node);
     } finally {
       _enclosingClass = outerClassElement;
     }
     return super.visitClassTypeAlias(node);
   }
   Object visitComment(Comment node) {
     _isInComment = true;
     try {
       return super.visitComment(node);
@@ skipping 293 matching lines @@
       return super.visitRedirectingConstructorInvocation(node);
     } finally {
       _isInConstructorInitializer = false;
     }
   }
   Object visitRethrowExpression(RethrowExpression node) {
     checkForRethrowOutsideCatch(node);
     return super.visitRethrowExpression(node);
   }
   Object visitReturnStatement(ReturnStatement node) {
+    if (node.expression == null) {
+      _returnWithoutCount++;
+    } else {
+      _returnWithCount++;
+    }
     checkForAllReturnStatementErrorCodes(node);
     return super.visitReturnStatement(node);
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     checkForConstFormalParameter(node);
     checkForPrivateOptionalParameter(node);
     return super.visitSimpleFormalParameter(node);
   }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     checkForReferenceToDeclaredVariableInInitializer(node);
@@ skipping 503 matching lines @@
   /**
    * This checks error related to the redirected constructors.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#REDIRECT_TO_INVALID_RETURN_TYPE
    * @see StaticWarningCode#REDIRECT_TO_INVALID_FUNCTION_TYPE
    * @see StaticWarningCode#REDIRECT_TO_MISSING_CONSTRUCTOR
    */
   bool checkForAllRedirectConstructorErrorCodes(ConstructorDeclaration node) {
-    ConstructorName redirectedNode = node.redirectedConstructor;
-    if (redirectedNode == null) {
+    ConstructorName redirectedConstructor = node.redirectedConstructor;
+    if (redirectedConstructor == null) {
       return false;
     }
-    ConstructorElement redirectedElement = redirectedNode.staticElement;
+    ConstructorElement redirectedElement = redirectedConstructor.staticElement;
     if (redirectedElement == null) {
-      TypeName constructorTypeName = redirectedNode.type;
+      TypeName constructorTypeName = redirectedConstructor.type;
       Type2 redirectedType = constructorTypeName.type;
       if (redirectedType != null && redirectedType.element != null && !redirectedType.isDynamic) {
         String constructorStrName = constructorTypeName.name.name;
-        if (redirectedNode.name != null) {
-          constructorStrName += ".${redirectedNode.name.name}";
+        if (redirectedConstructor.name != null) {
+          constructorStrName += ".${redirectedConstructor.name.name}";
         }
-        _errorReporter.reportError2(StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR, redirectedNode, [constructorStrName, redirectedType.displayName]);
+        _errorReporter.reportError2(StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR, redirectedConstructor, [constructorStrName, redirectedType.displayName]);
         return true;
       }
       return false;
     }
     FunctionType redirectedType = redirectedElement.type;
     Type2 redirectedReturnType = redirectedType.returnType;
     FunctionType constructorType = node.element.type;
     Type2 constructorReturnType = constructorType.returnType;
     if (!redirectedReturnType.isAssignableTo(constructorReturnType)) {
-      _errorReporter.reportError2(StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE, redirectedNode, [redirectedReturnType, constructorReturnType]);
+      _errorReporter.reportError2(StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE, redirectedConstructor, [redirectedReturnType, constructorReturnType]);
       return true;
     }
     if (!redirectedType.isSubtypeOf(constructorType)) {
-      _errorReporter.reportError2(StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE, redirectedNode, [redirectedType, constructorType]);
+      _errorReporter.reportError2(StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE, redirectedConstructor, [redirectedType, constructorType]);
       return true;
     }
     return false;
   }
 
   /**
    * This checks that the return statement of the form <i>return e;</i> is not in a generative
    * constructor.
    *
    * This checks that return statements without expressions are not in a generative constructor and
@@ skipping 1633 matching lines @@
     }
     return problemReported;
   }
 
   /**
    * Check to make sure that all similarly typed accessors are of the same type (including inherited
    * accessors).
    *
    * @param node the accessor currently being visited
    * @return `true` if and only if an error code is generated on the passed node
+   * @see StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES
+   * @see StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE
    */
   bool checkForMismatchedAccessorTypes(Declaration accessorDeclaration, String accessorTextName) {
     ExecutableElement accessorElement = accessorDeclaration.element as ExecutableElement;
     if (accessorElement is! PropertyAccessorElement) {
       return false;
     }
+    PropertyAccessorElement propertyAccessorElement = accessorElement as PropertyAccessorElement;
     PropertyAccessorElement counterpartAccessor = null;
-    PropertyAccessorElement propertyAccessorElement = accessorElement as PropertyAccessorElement;
+    ClassElement enclosingClassForCounterpart = null;
     if (propertyAccessorElement.isGetter) {
       counterpartAccessor = propertyAccessorElement.correspondingSetter;
     } else {
       counterpartAccessor = propertyAccessorElement.correspondingGetter;
       if (counterpartAccessor != null && identical(counterpartAccessor.enclosingElement, propertyAccessorElement.enclosingElement)) {
         return false;
       }
     }
     if (counterpartAccessor == null) {
-      return false;
+      if (_enclosingClass != null) {
+        String lookupIdentifier = propertyAccessorElement.name;
+        if (lookupIdentifier.endsWith("=")) {
+          lookupIdentifier = lookupIdentifier.substring(0, lookupIdentifier.length - 1);
+        } else {
+          lookupIdentifier += "=";
+        }
+        ExecutableElement elementFromInheritance = _inheritanceManager.lookupInheritance(_enclosingClass, lookupIdentifier);
+        if (elementFromInheritance != null && elementFromInheritance is PropertyAccessorElement) {
+          enclosingClassForCounterpart = elementFromInheritance.enclosingElement as ClassElement;
+          counterpartAccessor = elementFromInheritance as PropertyAccessorElement;
+        }
+      }
+      if (counterpartAccessor == null) {
+        return false;
+      }
     }
     Type2 getterType = null;
     Type2 setterType = null;
     if (propertyAccessorElement.isGetter) {
       getterType = getGetterType(propertyAccessorElement);
       setterType = getSetterType(counterpartAccessor);
     } else if (propertyAccessorElement.isSetter) {
       setterType = getSetterType(propertyAccessorElement);
-      counterpartAccessor = propertyAccessorElement.correspondingGetter;
       getterType = getGetterType(counterpartAccessor);
     }
     if (setterType != null && getterType != null && !getterType.isAssignableTo(setterType)) {
-      _errorReporter.reportError2(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES, accessorDeclaration, [
-          accessorTextName,
-          setterType.displayName,
-          getterType.displayName]);
+      if (enclosingClassForCounterpart == null) {
+        _errorReporter.reportError2(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES, accessorDeclaration, [
+            accessorTextName,
+            setterType.displayName,
+            getterType.displayName]);
+        return true;
+      } else {
+        _errorReporter.reportError2(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, accessorDeclaration, [
+            accessorTextName,
+            setterType.displayName,
+            getterType.displayName,
+            enclosingClassForCounterpart.displayName]);
+      }
+    }
+    return false;
+  }
+
+  /**
+   * This verifies that the given function body does not contain return statements that both have
+   * and do not have return values.
+   *
+   * @param node the function body being tested
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see StaticWarningCode#MIXED_RETURN_TYPES
+   */
+  bool checkForMixedReturns(BlockFunctionBody node) {
+    if (_returnWithCount > 0 && _returnWithoutCount > 0) {
+      _errorReporter.reportError2(StaticWarningCode.MIXED_RETURN_TYPES, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin does not have an explicitly declared constructor.
    *
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
@@ skipping 154 matching lines @@
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS
    */
   bool checkForNonAbstractClassInheritsAbstractMember(ClassDeclaration node) {
     if (_enclosingClass.isAbstract) {
       return false;
     }
     List<MethodElement> methods = _enclosingClass.methods;
     List<PropertyAccessorElement> accessors = _enclosingClass.accessors;
     Set<String> methodsInEnclosingClass = new Set<String>();
+    for (MethodElement method in methods) {
+      String methodName = method.name;
+      if (methodName == ElementResolver.NO_SUCH_METHOD_METHOD_NAME) {
+        return false;
+      }
+      javaSetAdd(methodsInEnclosingClass, methodName);
+    }
     Set<String> accessorsInEnclosingClass = new Set<String>();
-    for (MethodElement method in methods) {
-      javaSetAdd(methodsInEnclosingClass, method.name);
-    }
     for (PropertyAccessorElement accessor in accessors) {
       javaSetAdd(accessorsInEnclosingClass, accessor.name);
     }
-    if (methodsInEnclosingClass.contains(ElementResolver.NO_SUCH_METHOD_METHOD_NAME)) {
-      return false;
-    }
     Set<ExecutableElement> missingOverrides = new Set<ExecutableElement>();
     MemberMap membersInheritedFromInterfaces = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
     MemberMap membersInheritedFromSuperclasses = _inheritanceManager.getMapOfMembersInheritedFromClasses(_enclosingClass);
     for (int i = 0; i < membersInheritedFromInterfaces.size; i++) {
       String memberName = membersInheritedFromInterfaces.getKey(i);
       ExecutableElement executableElt = membersInheritedFromInterfaces.getValue(i);
       if (memberName == null) {
         break;
       }
       ExecutableElement elt = membersInheritedFromSuperclasses.get(executableElt.name);
@@ skipping 256 matching lines @@
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, redirectedConstructorNode, []);
     return true;
   }
 
   /**
    * This checks the class declaration is not a superinterface to itself.
    *
    * @param classElt the class element to test
-   * @param list a list containing the potentially cyclic implements path
    * @return `true` if and only if an error code is generated on the passed element
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS
    */
-  bool checkForRecursiveInterfaceInheritance(ClassElement classElt, List<ClassElement> list) {
+  bool checkForRecursiveInterfaceInheritance(ClassElement classElt) {
     if (classElt == null) {
       return false;
     }
-    InterfaceType supertype = classElt.supertype;
-    list.add(classElt);
-    if (list.length != 1 && _enclosingClass == classElt) {
+    return checkForRecursiveInterfaceInheritance2(classElt, new List<ClassElement>());
+  }
+
+  /**
+   * This checks the class declaration is not a superinterface to itself.
+   *
+   * @param classElt the class element to test
+   * @param path a list containing the potentially cyclic implements path
+   * @return `true` if and only if an error code is generated on the passed element
+   * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE
+   * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS
+   * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS
+   */
+  bool checkForRecursiveInterfaceInheritance2(ClassElement classElt, List<ClassElement> path) {
+    int size = path.length;
+    if (size > 0 && _enclosingClass == classElt) {
       String enclosingClassName = _enclosingClass.displayName;
-      if (list.length > 2) {
+      if (size > 1) {
         String separator = ", ";
-        int listLength = list.length;
         JavaStringBuilder builder = new JavaStringBuilder();
-        for (int i = 0; i < listLength; i++) {
-          builder.append(list[i].displayName);
-          if (i != listLength - 1) {
-            builder.append(separator);
-          }
+        for (int i = 0; i < size; i++) {
+          builder.append(path[i].displayName);
+          builder.append(separator);
         }
+        builder.append(classElt.displayName);
         _errorReporter.reportError3(CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName, builder.toString()]);
         return true;
-      } else if (list.length == 2) {
+      } else {
+        InterfaceType supertype = classElt.supertype;
         ErrorCode errorCode = (supertype != null && _enclosingClass == supertype.element ? CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS : CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS) as ErrorCode;
         _errorReporter.reportError3(errorCode, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName]);
         return true;
       }
     }
-    for (int i = 1; i < list.length - 1; i++) {
-      if (classElt == list[i]) {
-        list.removeAt(list.length - 1);
-        return false;
-      }
+    if (path.indexOf(classElt) > 0) {
+      return false;
     }
-    List<ClassElement> interfaceElements;
+    path.add(classElt);
+    InterfaceType supertype = classElt.supertype;
+    if (supertype != null && checkForRecursiveInterfaceInheritance2(supertype.element, path)) {
+      return true;
+    }
     List<InterfaceType> interfaceTypes = classElt.interfaces;
-    if (supertype != null && !supertype.isObject) {
-      interfaceElements = new List<ClassElement>(interfaceTypes.length + 1);
-      interfaceElements[0] = supertype.element;
-      for (int i = 0; i < interfaceTypes.length; i++) {
-        interfaceElements[i + 1] = interfaceTypes[i].element;
-      }
-    } else {
-      interfaceElements = new List<ClassElement>(interfaceTypes.length);
-      for (int i = 0; i < interfaceTypes.length; i++) {
-        interfaceElements[i] = interfaceTypes[i].element;
-      }
-    }
-    for (ClassElement classElt2 in interfaceElements) {
-      if (checkForRecursiveInterfaceInheritance(classElt2, list)) {
+    for (InterfaceType interfaceType in interfaceTypes) {
+      if (checkForRecursiveInterfaceInheritance2(interfaceType.element, path)) {
         return true;
       }
     }
-    list.removeAt(list.length - 1);
+    path.removeAt(path.length - 1);
     return false;
   }
 
   /**
    * This checks the passed constructor declaration has a valid combination of redirected
    * constructor invocation(s), super constructor invocations and field initializers.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR
+   * @see CompileTimeErrorCode#FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR
    * @see CompileTimeErrorCode#MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS
    * @see CompileTimeErrorCode#SUPER_IN_REDIRECTING_CONSTRUCTOR
-   * @see CompileTimeErrorCode#FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR
    */
   bool checkForRedirectingConstructorErrorCodes(ConstructorDeclaration node) {
-    int numProblems = 0;
+    bool errorReported = false;
+    ConstructorName redirectedConstructor = node.redirectedConstructor;
+    if (redirectedConstructor != null) {
+      for (FormalParameter parameter in node.parameters.parameters) {
+        if (parameter is DefaultFormalParameter && ((parameter as DefaultFormalParameter)).defaultValue != null) {
+          _errorReporter.reportError2(CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR, parameter.identifier, []);
+          errorReported = true;
+        }
+      }
+    }
     int numRedirections = 0;
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         if (numRedirections > 0) {
           _errorReporter.reportError2(CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS, initializer, []);
-          numProblems++;
+          errorReported = true;
         }
         numRedirections++;
       }
     }
     if (numRedirections > 0) {
       for (ConstructorInitializer initializer in node.initializers) {
         if (initializer is SuperConstructorInvocation) {
           _errorReporter.reportError2(CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR, initializer, []);
-          numProblems++;
+          errorReported = true;
         }
         if (initializer is ConstructorFieldInitializer) {
           _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR, initializer, []);
-          numProblems++;
+          errorReported = true;
         }
       }
     }
-    return numProblems != 0;
+    return errorReported;
   }
 
   /**
    * This checks if the passed constructor declaration has redirected constructor and references
    * itself directly or indirectly.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#REDIRECT_TO_NON_CONST_CONSTRUCTOR
    */
@@ skipping 619 matching lines @@
             firstIteration = false;
             break;
           } else {
             return true;
           }
         }
         if (current != null && !checked.contains(current)) {
           break;
         }
       }
-      current.accept(new GeneralizingElementVisitor_12(target, toCheck));
+      current.accept(new GeneralizingElementVisitor_14(target, toCheck));
       javaSetAdd(checked, current);
     }
   }
 
   /**
    * @return `true` if given [Type] implements operator <i>==</i>, and it is not
    *         <i>int</i> or <i>String</i>.
    */
   bool implementsEqualsWhenNotAllowed(Type2 type) {
     if (type == null || type == _typeProvider.intType || type == _typeProvider.stringType) {
@@ skipping 175 matching lines @@
   static final INIT_STATE INIT_IN_DECLARATION = new INIT_STATE('INIT_IN_DECLARATION', 1);
   static final INIT_STATE INIT_IN_FIELD_FORMAL = new INIT_STATE('INIT_IN_FIELD_FORMAL', 2);
   static final INIT_STATE INIT_IN_INITIALIZERS = new INIT_STATE('INIT_IN_INITIALIZERS', 3);
   static final List<INIT_STATE> values = [
       NOT_INIT,
       INIT_IN_DECLARATION,
       INIT_IN_FIELD_FORMAL,
       INIT_IN_INITIALIZERS];
   INIT_STATE(String name, int ordinal) : super(name, ordinal);
 }
-class GeneralizingElementVisitor_12 extends GeneralizingElementVisitor<Object> {
+class GeneralizingElementVisitor_14 extends GeneralizingElementVisitor<Object> {
   Element target;
   List<Element> toCheck;
-  GeneralizingElementVisitor_12(this.target, this.toCheck) : super();
+  GeneralizingElementVisitor_14(this.target, this.toCheck) : super();
   bool _inClass = false;
   Object visitClassElement(ClassElement element) {
     addTypeToCheck(element.supertype);
     for (InterfaceType mixin in element.mixins) {
       addTypeToCheck(mixin);
     }
     _inClass = !element.isTypedef;
     try {
       return super.visitClassElement(element);
     } finally {
       _inClass = false;
     }
   }
   Object visitExecutableElement(ExecutableElement element) {
     if (element.isSynthetic) {
       return null;
     }
     addTypeToCheck(element.returnType);
     return super.visitExecutableElement(element);
   }
   Object visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
     addTypeToCheck(element.returnType);
     return super.visitFunctionTypeAliasElement(element);
   }
   Object visitParameterElement(ParameterElement element) {
     addTypeToCheck(element.type);
     return super.visitParameterElement(element);
   }
-  Object visitTypeParameterElement(TypeParameterElement element) => null;
+  Object visitTypeParameterElement(TypeParameterElement element) {
+    addTypeToCheck(element.bound);
+    return super.visitTypeParameterElement(element);
+  }
   Object visitVariableElement(VariableElement element) {
     addTypeToCheck(element.type);
     return super.visitVariableElement(element);
   }
   void addTypeToCheck(Type2 type) {
     if (type == null) {
       return;
     }
     Element element = type.element;
     if (_inClass && target == element) {
@@ skipping 62 matching lines @@
   ResolverErrorCode.con2(String name, int ordinal, ErrorType type, String message, String correction) : super(name, ordinal) {
     this._type = type;
     this._message = message;
     this.correction9 = correction;
   }
   String get correction => correction9;
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
 }