Add UNDEFINED_HIDDEN_NAME, UNDEFINED_SHOWN_NAME

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 1914 matching lines @@
               HintCode.DEAD_CODE, node.thenExpression);
           node.elseExpression?.accept(this);
           return null;
         }
       }
     }
     return super.visitConditionalExpression(node);
   }
 
   @override
+  Object visitExportDirective(ExportDirective node) {
+    ExportElement exportElement = node.element;
+    if (exportElement != null) {
+      // 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);
+  }
+
+  @override
   Object visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
     conditionExpression?.accept(this);
     if (!_isDebugConstant(conditionExpression)) {
       EvaluationResultImpl result =
           _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.value.toBoolValue() == true) {
           // report error on else block: if(true) {} else {!}
           Statement elseStatement = node.elseStatement;
           if (elseStatement != null) {
             _errorReporter.reportErrorForNode(
                 HintCode.DEAD_CODE, elseStatement);
             node.thenStatement?.accept(this);
             return null;
           }
         } else {
           // report error on if block: if (false) {!} else {}
           _errorReporter.reportErrorForNode(
               HintCode.DEAD_CODE, node.thenStatement);
           node.elseStatement?.accept(this);
           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
+      LibraryElement library = importElement.importedLibrary;
+      if (library != null) {
+        for (Combinator combinator in node.combinators) {
+          _checkCombinator(library, combinator);
+        }
+      }
+    }
+    return super.visitImportDirective(node);
+  }
+
+  @override
   Object visitSwitchCase(SwitchCase node) {
     _checkForDeadStatementsInNodeList(node.statements);
     return super.visitSwitchCase(node);
   }
 
   @override
   Object visitSwitchDefault(SwitchDefault node) {
     _checkForDeadStatementsInNodeList(node.statements);
     return super.visitSwitchDefault(node);
   }
@@ skipping 79 matching lines @@
           _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.body);
           return null;
         }
       }
     }
     node.body?.accept(this);
     return null;
   }
 
   /**
+   * Resolve the names in the given [combinator] in the scope of the given
+   * [library].
+   */
+  void _checkCombinator(LibraryElement library, Combinator combinator) {
+    Namespace namespace =
+        new NamespaceBuilder().createExportNamespaceForLibrary(library);
+    NodeList<SimpleIdentifier> names;
+    if (combinator is HideCombinator) {

[Brian Wilkerson, 2016/04/20 21:34:25]

Can we pass in the list of names (and the hint code) so that we can avoid the
'is' checks? They're really expensive.

[srawlins, 2016/04/20 21:52:39]

I've uploaded another patch. Is this what you want? I don't see how to avoid
_any_ 'is' checks.

[Brian Wilkerson, 2016/04/20 22:49:32]

Close enough. I was thinking of

void _checkCombinator(LibraryElement library, Combinator combinator,
NodeList<SimpleIdentifier> names, ErrorCode hintCode)

and moving the type-specific code to the call sites, but this is better than
before.

+      names = combinator.hiddenNames;
+    } else {
+      names = (combinator as ShowCombinator).shownNames;
+    }
+    for (SimpleIdentifier name in names) {
+      String nameStr = name.name;
+      Element element = namespace.get(nameStr);
+      if (element == null) {
+        element = namespace.get("$nameStr=");
+      }
+      if (element == null) {
+        ErrorCode hintCode;
+        if (combinator is HideCombinator) {
+          hintCode = HintCode.UNDEFINED_HIDDEN_NAME;
+        } else {
+          hintCode = HintCode.UNDEFINED_SHOWN_NAME;
+        }
+        _errorReporter.reportErrorForNode(
+            hintCode, name, [library.identifier, nameStr]);
+      }
+    }
+  }
+
+  /**
    * Given some [NodeList] of [Statement]s, from either a [Block] or
    * [SwitchMember], this loops through the list in reverse order searching for statements
    * after a return, unlabeled break or unlabeled continue statement to mark them as dead code.
    *
    * @param statements some ordered list of statements in a [Block] or [SwitchMember]
    */
   void _checkForDeadStatementsInNodeList(NodeList<Statement> statements) {
     int size = statements.length;
     for (int i = 0; i < size; i++) {
       Statement currentStatement = statements[i];
@@ skipping 11019 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }