Use new Scope directly to simplify TypeNameResolver.

Change-Id: Ib3e78f2faca8a8cbdfb16d1a1bf5dc414cbf01ac
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/155830
Reviewed-by: Brian Wilkerson <[email protected]>

Author: scheglov

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

@@ -109,7 +109,6 @@ class ResolutionVisitor extends RecursiveAstVisitor<void> {
       libraryElement.typeSystem,
       typeProvider,
       isNonNullableByDefault,
-      libraryElement,
       errorReporter,
     );
 

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

@@ -24,7 +24,6 @@ class TypeNameResolver {
   final TypeSystemImpl typeSystem;
   final DartType dynamicType;
   final bool isNonNullableByDefault;
-  final LibraryElement definingLibrary; // TODO(scheglov) remove
   final ErrorReporter errorReporter;
 
   Scope nameScope;
@@ -52,7 +51,7 @@ class TypeNameResolver {
   ConstructorName rewriteResult;
 
   TypeNameResolver(this.typeSystem, TypeProvider typeProvider,
-      this.isNonNullableByDefault, this.definingLibrary, this.errorReporter)
+      this.isNonNullableByDefault, this.errorReporter)
       : dynamicType = typeProvider.dynamicType;
 
   NullabilitySuffix get _noneOrStarSuffix {
@@ -69,55 +68,51 @@ class TypeNameResolver {
     rewriteResult = null;
 
     var typeIdentifier = node.name;
+    if (typeIdentifier is PrefixedIdentifier) {
+      var prefix = typeIdentifier.prefix;
+      var prefixName = prefix.name;
+      var prefixElement = nameScope.lookup2(prefixName).getter;
+      prefix.staticElement = prefixElement;
 
-    if (typeIdentifier is SimpleIdentifier && typeIdentifier.name == 'void') {
-      node.type = VoidTypeImpl.instance;
-      return;
-    }
+      if (prefixElement == null) {
+        _resolveToElement(node, null);
+        return;
+      }
+
+      if (prefixElement is ClassElement) {
+        _rewriteToConstructorName(node, typeIdentifier);
+        return;
+      }
 
-    // TODO(scheglov) Update to use `lookup2`.
-    var element = nameScope.lookupIdentifier(typeIdentifier);
+      if (prefixElement is PrefixElement) {
+        var nameNode = typeIdentifier.identifier;
+        var name = nameNode.name;
 
-    // TODO(scheglov) When fixing the previous TODO, report the prefix sooner.
-    if (typeIdentifier is PrefixedIdentifier) {
-      var prefix = typeIdentifier.prefix;
-      var prefixElement = prefix.staticElement;
-      if (prefixElement != null &&
-          prefixElement is! PrefixElement &&
-          prefixElement is! ClassElement) {
-        errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.PREFIX_SHADOWED_BY_LOCAL_DECLARATION,
-          prefix,
-          [prefix.name],
-        );
-        node.type = dynamicType;
+        var element = prefixElement.scope.lookup2(name).getter;
+        nameNode.staticElement = element;
+        _resolveToElement(node, element);
         return;
       }
-    }
 
-    if (element is MultiplyDefinedElement) {
-      _setElement(typeIdentifier, element);
+      errorReporter.reportErrorForNode(
+        CompileTimeErrorCode.PREFIX_SHADOWED_BY_LOCAL_DECLARATION,
+        prefix,
+        [prefix.name],
+      );
       node.type = dynamicType;
-      return;
-    }
-
-    if (element != null) {
-      _setElement(typeIdentifier, element);
-      node.type = _instantiateElement(node, element);
-      return;
-    }
+    } else {
+      var nameNode = typeIdentifier as SimpleIdentifier;
+      var name = nameNode.name;
 
-    // TODO(scheglov) Can we do rewriting better with using `lookup2`?
-    if (_rewriteToConstructorName(node)) {
-      return;
-    }
+      if (name == 'void') {
+        node.type = VoidTypeImpl.instance;
+        return;
+      }
 
-    node.type = dynamicType;
-    if (nameScope.shouldIgnoreUndefined(typeIdentifier)) {
-      return;
+      var element = nameScope.lookup2(name).getter;
+      nameNode.staticElement = element;
+      _resolveToElement(node, element);
     }
-
-    _ErrorHelper(errorReporter).reportNullOrNonTypeElement(node, null);
   }
 
   /// Return type arguments, exactly [parameterCount].
@@ -306,61 +301,66 @@ class TypeNameResolver {
     }
   }
 
+  void _resolveToElement(TypeName node, Element element) {
+    if (element == null) {
+      node.type = dynamicType;
+      if (!nameScope.shouldIgnoreUndefined(node.name)) {
+        _ErrorHelper(errorReporter).reportNullOrNonTypeElement(node, null);
+      }
+      return;
+    }
+
+    if (element is MultiplyDefinedElement) {
+      node.type = dynamicType;
+      return;
+    }
+
+    node.type = _instantiateElement(node, element);
+  }
+
   /// We parse `foo.bar` as `prefix.Name` with the expectation that `prefix`
-  /// will be a [PrefixElement]. But we checked and found that `foo.bar` is
-  /// not in the scope, so try to see if it is `Class.constructor`.
-  ///
-  /// Return `true` if the node was rewritten as `Class.constructor`.
-  bool _rewriteToConstructorName(TypeName node) {
-    var typeIdentifier = node.name;
+  /// will be a [PrefixElement]. But when we resolved the `prefix` it turned
+  /// out to be a [ClassElement], so it is probably a `Class.constructor`.
+  void _rewriteToConstructorName(
+    TypeName node,
+    PrefixedIdentifier typeIdentifier,
+  ) {
     var constructorName = node.parent;
-    if (typeIdentifier is PrefixedIdentifier &&
-        constructorName is ConstructorName &&
-        constructorName.name == null) {
+    if (constructorName is ConstructorName && constructorName.name == null) {
       var classIdentifier = typeIdentifier.prefix;
-      var classElement = nameScope.lookupIdentifier(classIdentifier);
-      if (classElement is ClassElement) {
-        var constructorIdentifier = typeIdentifier.identifier;
-
-        var typeArguments = node.typeArguments;
-        if (typeArguments != null) {
-          errorReporter.reportErrorForNode(
-            StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_CONSTRUCTOR,
-            typeArguments,
-            [classIdentifier.name, constructorIdentifier.name],
-          );
-          var instanceCreation = constructorName.parent;
-          if (instanceCreation is InstanceCreationExpressionImpl) {
-            instanceCreation.typeArguments = typeArguments;
-          }
+      var constructorIdentifier = typeIdentifier.identifier;
+
+      var typeArguments = node.typeArguments;
+      if (typeArguments != null) {
+        errorReporter.reportErrorForNode(
+          StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_CONSTRUCTOR,
+          typeArguments,
+          [classIdentifier.name, constructorIdentifier.name],
+        );
+        var instanceCreation = constructorName.parent;
+        if (instanceCreation is InstanceCreationExpressionImpl) {
+          instanceCreation.typeArguments = typeArguments;
         }
+      }
 
-        node.name = classIdentifier;
-        node.typeArguments = null;
+      node.name = classIdentifier;
+      node.typeArguments = null;
 
-        constructorName.period = typeIdentifier.period;
-        constructorName.name = constructorIdentifier;
+      constructorName.period = typeIdentifier.period;
+      constructorName.name = constructorIdentifier;
 
-        rewriteResult = constructorName;
-        return true;
-      }
+      rewriteResult = constructorName;
+      return;
     }
 
-    return false;
-  }
-
-  /// Records the new Element for a TypeName's Identifier.
-  ///
-  /// A null may be passed in to indicate that the element can't be resolved.
-  /// (During a re-run of a task, it's important to clear any previous value
-  /// of the element.)
-  void _setElement(Identifier typeName, Element element) {
-    if (typeName is SimpleIdentifier) {
-      typeName.staticElement = element;
-    } else if (typeName is PrefixedIdentifier) {
-      typeName.identifier.staticElement = element;
-      SimpleIdentifier prefix = typeName.prefix;
-      prefix.staticElement = nameScope.lookupIdentifier(prefix);
+    if (_isInstanceCreation(node)) {
+      _ErrorHelper(errorReporter).reportNewWithNonType(node);
+    } else {
+      errorReporter.reportErrorForNode(
+        StaticWarningCode.NOT_A_TYPE,
+        typeIdentifier,
+        [typeIdentifier.name],
+      );
     }
   }
 

pkg/analyzer/test/src/diagnostics/not_a_type_test.dart

@@ -15,6 +15,30 @@ main() {
 
 @reflectiveTest
 class NotATypeTest extends DriverResolutionTest {
+  test_class_constructor() async {
+    await assertErrorsInCode('''
+class A {
+  A.foo();
+}
+
+A.foo bar() {}
+''', [
+      error(StaticWarningCode.NOT_A_TYPE, 24, 5),
+    ]);
+  }
+
+  test_class_method() async {
+    await assertErrorsInCode('''
+class A {
+  static void foo() {}
+}
+
+A.foo bar() {}
+''', [
+      error(StaticWarningCode.NOT_A_TYPE, 36, 5),
+    ]);
+  }
+
   test_extension() async {
     await assertErrorsInCode('''
 extension E on int {}