Suppress follow-on errors when a file is imported with either a prefix or a show clause

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.
 
 library analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 544 matching lines @@
       } else if (element is PropertyAccessorElement && element.isSynthetic) {
         // TODO(brianwilkerson) Why isn't this the implementation for PropertyAccessorElement?
         Element variable = element.variable;
         if (variable == null) {
           return false;
         }
         return variable.isDeprecated;
       }
       return element.isDeprecated;
     }
+
     if (!inDeprecatedMember && isDeprecated(element)) {
       String displayName = element.displayName;
       if (element is ConstructorElement) {
         // TODO(jwren) We should modify ConstructorElement.getDisplayName(),
         // or have the logic centralized elsewhere, instead of doing this logic
         // here.
         displayName = element.enclosingElement.displayName;
         if (!element.displayName.isEmpty) {
           displayName = "$displayName.${element.displayName}";
         }
@@ skipping 389 matching lines @@
         if (name.name == FunctionElement.NO_SUCH_METHOD_METHOD_NAME) {
           Element methodElement = name.staticElement;
           Element classElement = methodElement?.enclosingElement;
           return methodElement is MethodElement &&
               classElement is ClassElement &&
               !classElement.type.isObject;
         }
       }
       return false;
     }
+
     FunctionBody body = node.body;
     if (body is ExpressionFunctionBody) {
       if (isNonObjectNoSuchMethodInvocation(body.expression)) {
         _errorReporter.reportErrorForNode(
             HintCode.UNNECESSARY_NO_SUCH_METHOD, node);
         return true;
       }
     } else if (body is BlockFunctionBody) {
       List<Statement> statements = body.block.statements;
       if (statements.length == 1) {
@@ skipping 925 matching lines @@
           return null;
         }
       }
     }
     return super.visitConditionalExpression(node);
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
     ExportElement exportElement = node.element;
-    if (exportElement != null) {
+    if (exportElement != null && exportElement.context.exists(node.source)) {
       // The element is null when the URI is invalid
       LibraryElement library = exportElement.exportedLibrary;
       if (library != null) {
         for (Combinator combinator in node.combinators) {
           _checkCombinator(exportElement.exportedLibrary, combinator);
         }
       }
     }
     return super.visitExportDirective(node);
   }
@@ skipping 23 matching lines @@
           return null;
         }
       }
     }
     return super.visitIfStatement(node);
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     ImportElement importElement = node.element;
-    if (importElement != null) {
-      // The element is null when the URI is invalid
+    if (importElement != null && importElement.context.exists(node.source)) {
+      // The element is null when the URI is invalid, but not when the URI is
+      // valid but refers to a non-existent file.
       LibraryElement library = importElement.importedLibrary;
       if (library != null) {
         for (Combinator combinator in node.combinators) {
           _checkCombinator(library, combinator);
         }
       }
     }
     return super.visitImportDirective(node);
   }
 
@@ skipping 565 matching lines @@
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (property == null) {
         String elementName = nameOfMethod == '-' &&
-            node.parameters != null &&
-            node.parameters.parameters.isEmpty ? 'unary-' : nameOfMethod;
+                node.parameters != null &&
+                node.parameters.parameters.isEmpty
+            ? 'unary-'
+            : nameOfMethod;
         _enclosingExecutable = _findWithNameAndOffset(_enclosingClass.methods,
             methodName, elementName, methodName.offset);
         _expectedElements.remove(_enclosingExecutable);
         methodName.staticElement = _enclosingExecutable;
       } else {
         PropertyAccessorElement accessor;
         if (property.keyword == Keyword.GET) {
           accessor = _findIdentifier(_enclosingClass.accessors, methodName);
         } else if (property.keyword == Keyword.SET) {
           accessor = _findWithNameAndOffset(_enclosingClass.accessors,
@@ skipping 1394 matching lines @@
   bool _recordPrefixMap(SimpleIdentifier identifier, Element element) {
     bool recordIfTargetIsPrefixElement(Expression target) {
       if (target is SimpleIdentifier && target.staticElement is PrefixElement) {
         List<Element> prefixedElements = usedElements.prefixMap
             .putIfAbsent(target.staticElement, () => <Element>[]);
         prefixedElements.add(element);
         return true;
       }
       return false;
     }
+
     AstNode parent = identifier.parent;
     if (parent is MethodInvocation && parent.methodName == identifier) {
       return recordIfTargetIsPrefixElement(parent.target);
     }
     if (parent is PrefixedIdentifier && parent.identifier == identifier) {
       return recordIfTargetIsPrefixElement(parent.prefix);
     }
     return false;
   }
 
@@ skipping 456 matching lines @@
    *
    * Only call this method after all of the compilation units have been visited by this visitor.
    *
    * @param errorReporter the error reporter used to report the set of [HintCode.UNUSED_IMPORT]
    *          hints
    */
   void generateUnusedImportHints(ErrorReporter errorReporter) {
     int length = _unusedImports.length;
     for (int i = 0; i < length; i++) {
       ImportDirective unusedImport = _unusedImports[i];
-      // Check that the import isn't dart:core
+      // Check that the imported URI exists and isn't dart:core
       ImportElement importElement = unusedImport.element;
       if (importElement != null) {
         LibraryElement libraryElement = importElement.importedLibrary;
-        if (libraryElement != null && libraryElement.isDartCore) {
+        if (libraryElement == null ||
+            libraryElement.isDartCore ||
+            !importElement.context.exists(unusedImport.source)) {
           continue;
         }
       }
       errorReporter.reportErrorForNode(
           HintCode.UNUSED_IMPORT, unusedImport.uri);
     }
   }
 
   /**
    * Report an [HintCode.UNUSED_SHOWN_NAME] hint for each unused shown name.
@@ skipping 4078 matching lines @@
       if (typeName.name == voidType.name) {
         // There is no element for 'void'.
 //        if (argumentList != null) {
 //          // TODO(brianwilkerson) Report this error
 //          reporter.reportError(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, node, voidType.getName(), 0, argumentList.getArguments().size());
 //        }
         typeName.staticType = voidType;
         node.type = voidType;
         return;
       }
+      if (nameScope.shouldIgnoreUndefined(typeName)) {
+        typeName.staticType = undefinedType;
+        node.type = undefinedType;
+        return;
+      }
       //
       // If not, the look to see whether we might have created the wrong AST
       // structure for a constructor name. If so, fix the AST structure and then
       // proceed.
       //
       AstNode parent = node.parent;
       if (typeName is PrefixedIdentifier &&
           parent is ConstructorName &&
           argumentList == null) {
         ConstructorName name = parent;
         if (name.name == null) {
           PrefixedIdentifier prefixedIdentifier =
               typeName as PrefixedIdentifier;
           SimpleIdentifier prefix = prefixedIdentifier.prefix;
           element = nameScope.lookup(prefix, definingLibrary);
           if (element is PrefixElement) {
+            if (nameScope.shouldIgnoreUndefined(typeName)) {
+              typeName.staticType = undefinedType;
+              node.type = undefinedType;
+              return;
+            }
             AstNode grandParent = parent.parent;
             if (grandParent is InstanceCreationExpression &&
                 grandParent.isConst) {
               // If, if this is a const expression, then generate a
               // CompileTimeErrorCode.CONST_WITH_NON_TYPE error.
               reportErrorForNode(
                   CompileTimeErrorCode.CONST_WITH_NON_TYPE,
                   prefixedIdentifier.identifier,
                   [prefixedIdentifier.identifier.name]);
             } else {
@@ skipping 14 matching lines @@
             // constructor name. It arbitrarily chooses the former, but in this
             // case was wrong.
             //
             name.name = prefixedIdentifier.identifier;
             name.period = prefixedIdentifier.period;
             node.name = prefix;
             typeName = prefix;
           }
         }
       }
+      if (nameScope.shouldIgnoreUndefined(typeName)) {
+        typeName.staticType = undefinedType;
+        node.type = undefinedType;
+        return;
+      }
     }
     // check element
     bool elementValid = element is! MultiplyDefinedElement;
     if (elementValid &&
         element is! ClassElement &&
         _isTypeNameInInstanceCreationExpression(node)) {
       SimpleIdentifier typeNameSimple = _getTypeSimpleIdentifier(typeName);
       InstanceCreationExpression creation =
           node.parent.parent as InstanceCreationExpression;
       if (creation.isConst) {
@@ skipping 1801 matching lines @@
         errorReporter.reportErrorForNode(enumTypeError, typeName);
         return null;
       }
       return type;
     }
     // If the type is not an InterfaceType, then visitTypeName() sets the type
     // to be a DynamicTypeImpl
     Identifier name = typeName.name;
     if (name.name == Keyword.DYNAMIC.syntax) {
       errorReporter.reportErrorForNode(dynamicTypeError, name, [name.name]);
-    } else {
+    } else if (!nameScope.shouldIgnoreUndefined(name)) {
       errorReporter.reportErrorForNode(nonTypeError, name, [name.name]);
     }
     return null;
   }
 
   /**
    * Resolve the types in the given list of type names.
    *
    * @param typeNames the type names to be resolved
    * @param nonTypeError the error to produce if the type name is defined to be something other than
@@ skipping 578 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }