New analyzer snapshot, based on r35422.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // 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';
@@ skipping 3042 matching lines @@
       CatchClause catchClause = catchClauses[i];
       if (catchClause.onKeyword != null) {
         // on-catch clause found, verify that the exception type is not a subtype of a previous
         // on-catch exception type
         TypeName typeName = catchClause.exceptionType;
         if (typeName != null && typeName.type != null) {
           DartType currentType = typeName.type;
           if (currentType.isObject) {
             // Found catch clause clause that has Object as an exception type, this is equivalent to
             // having a catch clause that doesn't have an exception type, visit the block, but
-            // generate an error on any following catch clauses (and don't visit them).
+             // generate an error on any following catch clauses (and don't visit them).
             _safelyVisit(catchClause);
             if (i + 1 != numOfCatchClauses) {
-              // this catch clause is not the last in the try statement
+               // this catch clause is not the last in the try statement
               CatchClause nextCatchClause = catchClauses[i + 1];
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = nextCatchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
               return null;
             }
           }
           for (DartType type in visitedTypes) {
             if (currentType.isSubtypeOf(type)) {
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = catchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_ON_CATCH_SUBTYPE, offset, length, [currentType.displayName, type.displayName]);
               return null;
             }
           }
           visitedTypes.add(currentType);
         }
         _safelyVisit(catchClause);
       } else {
-        // Found catch clause clause that doesn't have an exception type, visit the block, but
+         // Found catch clause clause that doesn't have an exception type, visit the block, but
         // generate an error on any following catch clauses (and don't visit them).
         _safelyVisit(catchClause);
         if (i + 1 != numOfCatchClauses) {
           // this catch clause is not the last in the try statement
           CatchClause nextCatchClause = catchClauses[i + 1];
           CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
           int offset = nextCatchClause.offset;
           int length = lastCatchClause.end - offset;
           _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
           return null;
@@ skipping 34 matching lines @@
   ValidResult _getConstantBooleanValue(Expression expression) {
     if (expression is BooleanLiteral) {
       if (expression.value) {
         return new ValidResult(new DartObjectImpl(null, BoolState.from(true)));
       } else {
         return new ValidResult(new DartObjectImpl(null, BoolState.from(false)));
       }
     }
     // Don't consider situations where we could evaluate to a constant boolean expression with the
     // ConstantVisitor
-    //    else {
-    //      EvaluationResultImpl result = expression.accept(new ConstantVisitor());
-    //      if (result == ValidResult.RESULT_TRUE) {
-    //        return ValidResult.RESULT_TRUE;
-    //      } else if (result == ValidResult.RESULT_FALSE) {
-    //        return ValidResult.RESULT_FALSE;
-    //      }
-    //      return null;
-    //    }
+//
+       // else {
+//
+         // EvaluationResultImpl result = expression.accept(new ConstantVisitor());
+//
+         // if (result == ValidResult.RESULT_TRUE) {
+//
+           // return ValidResult.RESULT_TRUE;
+//
+         // } else if (result == ValidResult.RESULT_FALSE) {
+//
+           // return ValidResult.RESULT_FALSE;
+//
+         // }
+//
+         // return null;
+//
+       // }
     return null;
   }
 
   /**
    * Return `true` if and only if the passed expression is resolved to a constant variable.
    *
    * @param expression some conditional expression
    * @return `true` if and only if the passed expression is resolved to a constant variable
    */
   bool _isDebugConstant(Expression expression) {
@@ skipping 6751 matching lines @@
                 if (prefix == null) {
                   prefix = new PrefixElementImpl(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (analysisContext.computeKindOf(importedSource) != SourceKind.LIBRARY) {
-                _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
+                ErrorCode errorCode = (importElement.isDeferred ? StaticWarningCode.IMPORT_OF_NON_LIBRARY : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
+                _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, errorCode, [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive;
           Source exportedSource = exportDirective.source;
           if (exportedSource != null) {
             // The exported source will be null if the URI in the export directive was invalid.
             Library exportedLibrary = _libraryMap[exportedSource];
             if (exportedLibrary != null) {
@@ skipping 556 matching lines @@
                 if (prefix == null) {
                   prefix = new PrefixElementImpl(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (analysisContext.computeKindOf(importedSource) != SourceKind.LIBRARY) {
-                _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
+                ErrorCode errorCode = (importElement.isDeferred ? StaticWarningCode.IMPORT_OF_NON_LIBRARY : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
+                _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, errorCode, [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive;
           Source exportedSource = exportDirective.source;
           if (exportedSource != null && analysisContext.exists(exportedSource)) {
             // The exported source will be null if the URI in the export directive was invalid.
             ResolvableLibrary exportedLibrary = _libraryMap[exportedSource];
             if (exportedLibrary != null) {
@@ skipping 745 matching lines @@
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     sc.TokenType operatorType = node.operator.type;
     Expression leftOperand = node.leftOperand;
     Expression rightOperand = node.rightOperand;
     if (operatorType == sc.TokenType.AMPERSAND_AMPERSAND) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
+        _overrideManager.enterScope();
         try {
-          _overrideManager.enterScope();
           _promoteManager.enterScope();
-          _propagateTrueState(leftOperand);
-          // Type promotion.
-          _promoteTypes(leftOperand);
-          _clearTypePromotionsIfPotentiallyMutatedIn(leftOperand);
-          _clearTypePromotionsIfPotentiallyMutatedIn(rightOperand);
-          _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(rightOperand);
-          // Visit right operand.
-          rightOperand.accept(this);
+          try {
+            _propagateTrueState(leftOperand);
+            // Type promotion.
+            _promoteTypes(leftOperand);
+            _clearTypePromotionsIfPotentiallyMutatedIn(leftOperand);
+            _clearTypePromotionsIfPotentiallyMutatedIn(rightOperand);
+            _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(rightOperand);
+            // Visit right operand.
+            rightOperand.accept(this);
+          } finally {
+            _promoteManager.exitScope();
+          }
         } finally {
           _overrideManager.exitScope();
-          _promoteManager.exitScope();
         }
       }
     } else if (operatorType == sc.TokenType.BAR_BAR) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
+        _overrideManager.enterScope();
         try {
-          _overrideManager.enterScope();
           _propagateFalseState(leftOperand);
           rightOperand.accept(this);
         } finally {
           _overrideManager.exitScope();
         }
       }
     } else {
       safelyVisit(leftOperand);
       safelyVisit(rightOperand);
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     safelyVisit(_commentBeforeFunction);
+    _overrideManager.enterScope();
     try {
-      _overrideManager.enterScope();
       super.visitBlockFunctionBody(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) {
     //
@@ skipping 44 matching lines @@
   @override
   Object visitCompilationUnit(CompilationUnit node) {
     //
     // TODO(brianwilkerson) The goal of the code below is to visit the declarations in such an
     // order that we can infer type information for top-level variables before we visit references
     // to them. This is better than making no effort, but still doesn't completely satisfy that
     // goal (consider for example "final var a = b; final var b = 0;"; we'll infer a type of 'int'
     // for 'b', but not for 'a' because of the order of the visits). Ideally we would create a
     // dependency graph, but that would require references to be resolved, which they are not.
     //
+    _overrideManager.enterScope();
     try {
-      _overrideManager.enterScope();
       NodeList<Directive> directives = node.directives;
       int directiveCount = directives.length;
       for (int i = 0; i < directiveCount; i++) {
         directives[i].accept(this);
       }
       NodeList<CompilationUnitMember> declarations = node.declarations;
       int declarationCount = declarations.length;
       for (int i = 0; i < declarationCount; i++) {
         CompilationUnitMember declaration = declarations[i];
         if (declaration is! ClassDeclaration) {
@@ skipping 13 matching lines @@
     node.accept(_typeAnalyzer);
     return null;
   }
 
   @override
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Expression thenExpression = node.thenExpression;
     if (thenExpression != null) {
+      _overrideManager.enterScope();
       try {
-        _overrideManager.enterScope();
         _promoteManager.enterScope();
-        _propagateTrueState(condition);
-        // Type promotion.
-        _promoteTypes(condition);
-        _clearTypePromotionsIfPotentiallyMutatedIn(thenExpression);
-        _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenExpression);
-        // Visit "then" expression.
-        thenExpression.accept(this);
+        try {
+          _propagateTrueState(condition);
+          // Type promotion.
+          _promoteTypes(condition);
+          _clearTypePromotionsIfPotentiallyMutatedIn(thenExpression);
+          _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenExpression);
+          // Visit "then" expression.
+          thenExpression.accept(this);
+        } finally {
+          _promoteManager.exitScope();
+        }
       } finally {
         _overrideManager.exitScope();
-        _promoteManager.exitScope();
       }
     }
     Expression elseExpression = node.elseExpression;
     if (elseExpression != null) {
+      _overrideManager.enterScope();
       try {
-        _overrideManager.enterScope();
         _propagateFalseState(condition);
         elseExpression.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     bool thenIsAbrupt = _isAbruptTerminationExpression(thenExpression);
     bool elseIsAbrupt = _isAbruptTerminationExpression(elseExpression);
@@ skipping 47 matching lines @@
     //
     // We do not visit the label because it needs to be visited in the context of the statement.
     //
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   @override
   Object visitDoStatement(DoStatement node) {
+    _overrideManager.enterScope();
     try {
-      _overrideManager.enterScope();
       super.visitDoStatement(node);
     } finally {
       _overrideManager.exitScope();
     }
     // TODO(brianwilkerson) If the loop can only be exited because the condition is false, then
     // propagateFalseState(node.getCondition());
     return null;
   }
 
   @override
   Object visitEmptyFunctionBody(EmptyFunctionBody node) {
     safelyVisit(_commentBeforeFunction);
     return super.visitEmptyFunctionBody(node);
   }
 
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     safelyVisit(_commentBeforeFunction);
+    _overrideManager.enterScope();
     try {
-      _overrideManager.enterScope();
       super.visitExpressionFunctionBody(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
+    _overrideManager.enterScope();
     try {
-      _overrideManager.enterScope();
       super.visitFieldDeclaration(node);
     } finally {
       Map<Element, DartType> overrides = _overrideManager.captureOverrides(node.fields);
       _overrideManager.exitScope();
       _overrideManager.applyOverrides(overrides);
     }
     return null;
   }
 
   @override
   Object visitForEachStatement(ForEachStatement node) {
+    _overrideManager.enterScope();
     try {
-      _overrideManager.enterScope();
       super.visitForEachStatement(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
   Object visitForStatement(ForStatement node) {
+    _overrideManager.enterScope();
     try {
-      _overrideManager.enterScope();
       super.visitForStatement(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       SimpleIdentifier functionName = node.name;
       _enclosingFunction = functionName.staticElement as ExecutableElement;
       super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
     return null;
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       _overrideManager.enterScope();
-      super.visitFunctionExpression(node);
+      try {
+        super.visitFunctionExpression(node);
+      } finally {
+        _overrideManager.exitScope();
+      }
     } finally {
-      _overrideManager.exitScope();
       _enclosingFunction = outerFunction;
     }
     return null;
   }
 
   @override
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     safelyVisit(node.function);
     node.accept(_elementResolver);
     _inferFunctionExpressionsParametersTypes(node.argumentList);
     safelyVisit(node.argumentList);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   @override
   Object visitHideCombinator(HideCombinator node) => null;
 
   @override
   Object visitIfStatement(IfStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Map<Element, DartType> thenOverrides = null;
     Statement thenStatement = node.thenStatement;
     if (thenStatement != null) {
+      _overrideManager.enterScope();
       try {
-        _overrideManager.enterScope();
         _promoteManager.enterScope();
-        _propagateTrueState(condition);
-        // Type promotion.
-        _promoteTypes(condition);
-        _clearTypePromotionsIfPotentiallyMutatedIn(thenStatement);
-        _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenStatement);
-        // Visit "then".
-        visitStatementInScope(thenStatement);
+        try {
+          _propagateTrueState(condition);
+          // Type promotion.
+          _promoteTypes(condition);
+          _clearTypePromotionsIfPotentiallyMutatedIn(thenStatement);
+          _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenStatement);
+          // Visit "then".
+          visitStatementInScope(thenStatement);
+        } finally {
+          _promoteManager.exitScope();
+        }
       } finally {
         thenOverrides = _overrideManager.captureLocalOverrides();
         _overrideManager.exitScope();
-        _promoteManager.exitScope();
       }
     }
     Map<Element, DartType> elseOverrides = null;
     Statement elseStatement = node.elseStatement;
     if (elseStatement != null) {
+      _overrideManager.enterScope();
       try {
-        _overrideManager.enterScope();
         _propagateFalseState(condition);
         visitStatementInScope(elseStatement);
       } finally {
         elseOverrides = _overrideManager.captureLocalOverrides();
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     bool thenIsAbrupt = _isAbruptTerminationStatement(thenStatement);
@@ skipping 98 matching lines @@
     // visited in the context of the constructor invocation.
     //
     safelyVisit(node.argumentList);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
+    _overrideManager.enterScope();
     try {
-      _overrideManager.enterScope();
       super.visitSwitchCase(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
   Object visitSwitchDefault(SwitchDefault node) {
+    _overrideManager.enterScope();
     try {
-      _overrideManager.enterScope();
       super.visitSwitchDefault(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+    _overrideManager.enterScope();
     try {
-      _overrideManager.enterScope();
       super.visitTopLevelVariableDeclaration(node);
     } finally {
       Map<Element, DartType> overrides = _overrideManager.captureOverrides(node.variables);
       _overrideManager.exitScope();
       _overrideManager.applyOverrides(overrides);
     }
     return null;
   }
 
   @override
   Object visitTypeName(TypeName node) => null;
 
   @override
   Object visitWhileStatement(WhileStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Statement body = node.body;
     if (body != null) {
+      _overrideManager.enterScope();
       try {
-        _overrideManager.enterScope();
         _propagateTrueState(condition);
         visitStatementInScope(body);
       } finally {
         _overrideManager.exitScope();
       }
     }
     // TODO(brianwilkerson) If the loop can only be exited because the condition is false, then
     // propagateFalseState(condition);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
@@ skipping 140 matching lines @@
     // while visiting the iterator.
     //
     Expression iterator = node.iterator;
     safelyVisit(iterator);
     DeclaredIdentifier loopVariable = node.loopVariable;
     SimpleIdentifier identifier = node.identifier;
     safelyVisit(loopVariable);
     safelyVisit(identifier);
     Statement body = node.body;
     if (body != null) {
+      _overrideManager.enterScope();
       try {
-        _overrideManager.enterScope();
         if (loopVariable != null && iterator != null) {
           LocalVariableElement loopElement = loopVariable.element;
           if (loopElement != null) {
             DartType iteratorElementType = _getIteratorElementType(iterator);
             overrideVariable(loopElement, iteratorElementType);
             _recordPropagatedType(loopVariable.identifier, iteratorElementType);
           }
         } else if (identifier != null && iterator != null) {
           Element identifierElement = identifier.staticElement;
           if (identifierElement is VariableElement) {
@@ skipping 6549 matching lines @@
       WithClause withClause = node.withClause;
       _checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
       _checkForMemberWithClassName();
       _checkForNoDefaultSuperConstructorImplicit(node);
       _checkForConflictingTypeVariableErrorCodes(node);
       // Only do error checks on the clause nodes if there is a non-null clause
       if (implementsClause != null || extendsClause != null || withClause != null) {
         // Only check for all of the inheritance logic around clauses if there isn't an error code
         // such as "Cannot extend double" already on the class.
         if (!_checkForImplementsDisallowedClass(implementsClause) && !_checkForExtendsDisallowedClass(extendsClause) && !_checkForAllMixinErrorCodes(withClause)) {
+          _checkForExtendsDeferredClass(extendsClause);
+          _checkForImplementsDeferredClass(implementsClause);
           _checkForNonAbstractClassInheritsAbstractMember(node.name);
           _checkForInconsistentMethodInheritance();
           _checkForRecursiveInterfaceInheritance(_enclosingClass);
           _checkForConflictingGetterAndMethod();
           _checkForConflictingInstanceGetterAndSuperclassMember();
           _checkImplementsSuperClass(node);
           _checkImplementsFunctionWithoutCall(node);
         }
       }
       // initialize initialFieldElementsMap
@@ skipping 20 matching lines @@
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     _checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     ClassElement outerClassElement = _enclosingClass;
     try {
       _enclosingClass = node.element;
       // Only check for all of the inheritance logic around clauses if there isn't an error code
       // such as "Cannot extend double" already on the class.
       if (!_checkForExtendsDisallowedClassInTypeAlias(node) && !_checkForImplementsDisallowedClass(node.implementsClause) && !_checkForAllMixinErrorCodes(node.withClause)) {
+        _checkForExtendsDeferredClassInTypeAlias(node);
+        _checkForImplementsDeferredClass(node.implementsClause);
         _checkForRecursiveInterfaceInheritance(node.element);
         _checkForTypeAliasCannotReferenceItself_mixin(node);
         _checkForNonAbstractClassInheritsAbstractMember(node.name);
       }
     } finally {
       _enclosingClass = outerClassElement;
     }
     return super.visitClassTypeAlias(node);
   }
 
@@ skipping 119 matching lines @@
       _isInInstanceVariableDeclaration = false;
     }
   }
 
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     _checkForValidField(node);
     _checkForConstFormalParameter(node);
     _checkForPrivateOptionalParameter(node);
     _checkForFieldInitializingFormalRedirectingConstructor(node);
+    _checkForTypeAnnotationDeferredClass(node.type);
     return super.visitFieldFormalParameter(node);
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       SimpleIdentifier identifier = node.name;
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.name;
       }
       _enclosingFunction = node.element;
       if (node.isSetter || node.isGetter) {
         _checkForMismatchedAccessorTypes(node, methodName);
         if (node.isSetter) {
           FunctionExpression functionExpression = node.functionExpression;
           if (functionExpression != null) {
             _checkForWrongNumberOfParametersForSetter(node.name, functionExpression.parameters);
           }
           TypeName returnType = node.returnType;
           _checkForNonVoidReturnTypeForSetter(returnType);
         }
       }
+      _checkForTypeAnnotationDeferredClass(node.returnType);
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     // If this function expression is wrapped in a function declaration, don't change the
     // enclosingFunction field.
@@ skipping 26 matching lines @@
     _checkForDefaultValueInFunctionTypeAlias(node);
     _checkForTypeAliasCannotReferenceItself_function(node);
     return super.visitFunctionTypeAlias(node);
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     bool old = _isInFunctionTypedFormalParameter;
     _isInFunctionTypedFormalParameter = true;
     try {
+      _checkForTypeAnnotationDeferredClass(node.returnType);
       return super.visitFunctionTypedFormalParameter(node);
     } finally {
       _isInFunctionTypedFormalParameter = old;
     }
   }
 
   @override
   Object visitIfStatement(IfStatement node) {
     _checkForNonBoolCondition(node.condition);
     return super.visitIfStatement(node);
@@ skipping 25 matching lines @@
       ConstructorName constructorName = node.constructorName;
       TypeName typeName = constructorName.type;
       DartType type = typeName.type;
       if (type is InterfaceType) {
         InterfaceType interfaceType = type;
         _checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
         if (_isInConstInstanceCreation) {
           _checkForConstWithNonConst(node);
           _checkForConstWithUndefinedConstructor(node);
           _checkForConstWithTypeParametersInCreation(node);
+          _checkForConstDeferredClass(node, constructorName, typeName);
         } else {
           _checkForNewWithUndefinedConstructor(node);
         }
       }
       return super.visitInstanceCreationExpression(node);
     } finally {
       _isInConstInstanceCreation = false;
     }
   }
 
@@ skipping 35 matching lines @@
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = _enclosingFunction;
     try {
       _isInStaticMethod = node.isStatic;
       _enclosingFunction = node.element;
       SimpleIdentifier identifier = node.name;
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.name;
       }
+      TypeName returnTypeName = node.returnType;
       if (node.isSetter || node.isGetter) {
         _checkForMismatchedAccessorTypes(node, methodName);
       }
       if (node.isGetter) {
         _checkForVoidReturnType(node);
         _checkForConflictingStaticGetterAndInstanceSetter(node);
       } else if (node.isSetter) {
         _checkForWrongNumberOfParametersForSetter(node.name, node.parameters);
-        _checkForNonVoidReturnTypeForSetter(node.returnType);
+        _checkForNonVoidReturnTypeForSetter(returnTypeName);
         _checkForConflictingStaticSetterAndInstanceMember(node);
       } else if (node.isOperator) {
         _checkForOptionalParameterInOperator(node);
         _checkForWrongNumberOfParametersForOperator(node);
         _checkForNonVoidReturnTypeForOperator(node);
       }
       _checkForConcreteClassWithAbstractMember(node);
       _checkForAllInvalidOverrideErrorCodesForMethod(node);
+      _checkForTypeAnnotationDeferredClass(returnTypeName);
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingFunction = previousFunction;
       _isInStaticMethod = false;
     }
   }
 
   @override
   Object visitMethodInvocation(MethodInvocation node) {
     Expression target = node.realTarget;
@@ skipping 87 matching lines @@
       _returnsWith.add(node);
     }
     _checkForAllReturnStatementErrorCodes(node);
     return super.visitReturnStatement(node);
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     _checkForConstFormalParameter(node);
     _checkForPrivateOptionalParameter(node);
+    _checkForTypeAnnotationDeferredClass(node.type);
     return super.visitSimpleFormalParameter(node);
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     _checkForImplicitThisReferenceInInitializer(node);
     if (!_isUnqualifiedReferenceToNonLocalStaticMemberAllowed(node)) {
       _checkForUnqualifiedReferenceToNonLocalStaticMember(node);
     }
     return super.visitSimpleIdentifier(node);
@@ skipping 39 matching lines @@
   Object visitTypeName(TypeName node) {
     _checkForTypeArgumentNotMatchingBounds(node);
     _checkForTypeParameterReferencedByStatic(node);
     return super.visitTypeName(node);
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
     _checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME);
     _checkForTypeParameterSupertypeOfItsBound(node);
+    _checkForTypeAnnotationDeferredClass(node.bound);
     return super.visitTypeParameter(node);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     SimpleIdentifier nameNode = node.name;
     Expression initializerNode = node.initializer;
     // do checks
     _checkForInvalidAssignment(nameNode, initializerNode);
     // visit name
     nameNode.accept(this);
     // visit initializer
     String name = nameNode.name;
     _namesForReferenceToDeclaredVariableInInitializer.add(name);
     _isInInstanceVariableInitializer = _isInInstanceVariableDeclaration;
     try {
       if (initializerNode != null) {
         initializerNode.accept(this);
       }
     } finally {
       _isInInstanceVariableInitializer = false;
       _namesForReferenceToDeclaredVariableInInitializer.remove(name);
     }
     // done
     return null;
   }
 
   @override
-  Object visitVariableDeclarationList(VariableDeclarationList node) => super.visitVariableDeclarationList(node);
+  Object visitVariableDeclarationList(VariableDeclarationList node) {
+    _checkForTypeAnnotationDeferredClass(node.type);
+    return super.visitVariableDeclarationList(node);
+  }
 
   @override
   Object visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     _checkForFinalNotInitialized(node.variables);
     return super.visitVariableDeclarationStatement(node);
   }
 
   @override
   Object visitWhileStatement(WhileStatement node) {
     _checkForNonBoolCondition(node.condition);
@@ skipping 497 matching lines @@
     bool problemReported = false;
     for (TypeName mixinName in withClause.mixinTypes) {
       DartType mixinType = mixinName.type;
       if (mixinType is! InterfaceType) {
         continue;
       }
       if (_checkForExtendsOrImplementsDisallowedClass(mixinName, CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS)) {
         problemReported = true;
       } else {
         ClassElement mixinElement = (mixinType as InterfaceType).element;
+        problemReported = javaBooleanOr(problemReported, _checkForExtendsOrImplementsDeferredClass(mixinName, CompileTimeErrorCode.MIXIN_DEFERRED_CLASS));
         problemReported = javaBooleanOr(problemReported, _checkForMixinDeclaresConstructor(mixinName, mixinElement));
         problemReported = javaBooleanOr(problemReported, _checkForMixinInheritsNotFromObject(mixinName, mixinElement));
         problemReported = javaBooleanOr(problemReported, _checkForMixinReferencesSuper(mixinName, mixinElement));
       }
     }
     return problemReported;
   }
 
   /**
    * This checks error related to the redirected constructors.
@@ skipping 816 matching lines @@
     ClassElement classElement = constructorElement.enclosingElement;
     if (!classElement.hasNonFinalField) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD, node, []);
     return true;
   }
 
   /**
+   * This verifies that the passed 'const' instance creation expression is not creating a deferred
+   * type.
+   *
+   * @param node the instance creation expression to evaluate
+   * @param constructorName the constructor name from the instance creation expression
+   * @param typeName the type name off of the constructor name
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#CONST_DEFERRED_CLASS
+   */
+  bool _checkForConstDeferredClass(InstanceCreationExpression node, ConstructorName constructorName, TypeName typeName) {
+    if (typeName.isDeferred) {
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_DEFERRED_CLASS, constructorName, [typeName.name.name]);
+      return true;
+    }
+    return false;
+  }
+
+  /**
    * This verifies that the passed throw expression is not enclosed in a 'const' constructor
    * declaration.
    *
    * @param node the throw expression expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_CONSTRUCTOR_THROWS_EXCEPTION
    */
   bool _checkForConstEvalThrowsException(ThrowExpression node) {
     if (_isEnclosingConstructorConst) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION, node, []);
@@ skipping 398 matching lines @@
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
+   * This verifies that the passed extends clause does not extend a deferred class.
+   *
+   * @param node the extends clause to test
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#EXTENDS_DEFERRED_CLASS
+   */
+  bool _checkForExtendsDeferredClass(ExtendsClause node) {
+    if (node == null) {
+      return false;
+    }
+    return _checkForExtendsOrImplementsDeferredClass(node.superclass, CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
+  }
+
+  /**
+   * This verifies that the passed type alias does not extend a deferred class.
+   *
+   * @param node the extends clause to test
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
+   */
+  bool _checkForExtendsDeferredClassInTypeAlias(ClassTypeAlias node) {
+    if (node == null) {
+      return false;
+    }
+    return _checkForExtendsOrImplementsDeferredClass(node.superclass, CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
+  }
+
+  /**
    * This verifies that the passed extends clause does not extend classes such as num or String.
    *
    * @param node the extends clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
    */
   bool _checkForExtendsDisallowedClass(ExtendsClause node) {
     if (node == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDisallowedClass(node.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
   }
 
   /**
    * This verifies that the passed type alias does not extend classes such as num or String.
    *
    * @param node the extends clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
    */
   bool _checkForExtendsDisallowedClassInTypeAlias(ClassTypeAlias node) {
     if (node == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDisallowedClass(node.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
   }
 
   /**
-   * This verifies that the passed type name does not extend or implement classes such as 'num' or
-   * 'String'.
+   * This verifies that the passed type name does not extend, implement or mixin classes that are
+   * deferred.
+   *
+   * @param node the type name to test
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see #checkForExtendsDeferredClass(ExtendsClause)
+   * @see #checkForExtendsDeferredClassInTypeAlias(ClassTypeAlias)
+   * @see #checkForImplementsDeferredClass(ImplementsClause)
+   * @see #checkForAllMixinErrorCodes(WithClause)
+   * @see CompileTimeErrorCode#EXTENDS_DEFERRED_CLASS
+   * @see CompileTimeErrorCode#IMPLEMENTS_DEFERRED_CLASS
+   * @see CompileTimeErrorCode#MIXIN_DEFERRED_CLASS
+   */
+  bool _checkForExtendsOrImplementsDeferredClass(TypeName typeName, ErrorCode errorCode) {
+    if (typeName.isSynthetic) {
+      return false;
+    }
+    if (typeName.isDeferred) {
+      _errorReporter.reportErrorForNode(errorCode, typeName, [typeName.name.name]);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * This verifies that the passed type name does not extend, implement or mixin classes such as
+   * 'num' or 'String'.
    *
    * @param node the type name to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see #checkForExtendsDisallowedClass(ExtendsClause)
+   * @see #checkForExtendsDisallowedClassInTypeAlias(ClassTypeAlias)
    * @see #checkForImplementsDisallowedClass(ImplementsClause)
+   * @see #checkForAllMixinErrorCodes(WithClause)
    * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
    * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
+   * @see CompileTimeErrorCode#MIXIN_OF_DISALLOWED_CLASS
    */
   bool _checkForExtendsOrImplementsDisallowedClass(TypeName typeName, ErrorCode errorCode) {
     if (typeName.isSynthetic) {
       return false;
     }
     DartType superType = typeName.type;
     for (InterfaceType disallowedType in _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT) {
       if (superType != null && superType == disallowedType) {
         // if the violating type happens to be 'num', we need to rule out the case where the
         // enclosing class is 'int' or 'double'
@@ skipping 142 matching lines @@
     for (ClassMember classMember in classMembers) {
       if (classMember is FieldDeclaration) {
         FieldDeclaration field = classMember;
         foundError = javaBooleanOr(foundError, _checkForFinalNotInitialized(field.fields));
       }
     }
     return foundError;
   }
 
   /**
+   * This verifies that the passed implements clause does not implement classes that are deferred.
+   *
+   * @param node the implements clause to test
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#IMPLEMENTS_DEFERRED_CLASS
+   */
+  bool _checkForImplementsDeferredClass(ImplementsClause node) {
+    if (node == null) {
+      return false;
+    }
+    bool foundError = false;
+    for (TypeName type in node.interfaces) {
+      foundError = javaBooleanOr(foundError, _checkForExtendsOrImplementsDeferredClass(type, CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS));
+    }
+    return foundError;
+  }
+
+  /**
    * This verifies that the passed implements clause does not implement classes such as 'num' or
    * 'String'.
    *
    * @param node the implements clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
    */
   bool _checkForImplementsDisallowedClass(ImplementsClause node) {
     if (node == null) {
       return false;
@@ skipping 1405 matching lines @@
   bool _checkForTypeAliasCannotReferenceItself_mixin(ClassTypeAlias node) {
     ClassElement element = node.element;
     if (!_hasTypedefSelfReference(element)) {
       return false;
     }
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, node, []);
     return true;
   }
 
   /**
+   * This verifies that the passed type name is not a deferred type.
+   *
+   * @param expression the expression to evaluate
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see StaticWarningCode#TYPE_ANNOTATION_DEFERRED_CLASS
+   */
+  bool _checkForTypeAnnotationDeferredClass(TypeName node) {
+    if (node != null && node.isDeferred) {
+      _errorReporter.reportErrorForNode(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, node, [node.name]);
+    }
+    return false;
+  }
+
+  /**
    * This verifies that the type arguments in the passed type name are all within their bounds.
    *
    * @param node the [TypeName] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
    */
   bool _checkForTypeArgumentNotMatchingBounds(TypeName node) {
     if (node.typeArguments == null) {
       return false;
     }
@@ skipping 802 matching lines @@
    *
    * @param type the type of this error
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
   const ResolverErrorCode.con2(String name, int ordinal, this.type, this.message, this.correction) : super(name, ordinal);
 
   @override
   ErrorSeverity get errorSeverity => type.severity;
 }