analyzer: add constructor references from PrefixedIdentifier

Bug: #46020
Change-Id: Ifafea6edb6c9ce7fdf1c1f092ff278738c273bb0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/209300
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>
Commit-Queue: Samuel Rawlins <srawlins@google.com>

Author: srawlins

pkg/analyzer/lib/error/error.dart

@@ -141,6 +141,7 @@ const List<ErrorCode> errorCodeValues = [
   CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS,
   CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR,
   CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT,
+  CompileTimeErrorCode.CONSTRUCTOR_TEAROFFS_NOT_ENABLED,
   CompileTimeErrorCode.CONTINUE_LABEL_ON_SWITCH,
   CompileTimeErrorCode.COULD_NOT_INFER,
   CompileTimeErrorCode.DEFAULT_LIST_CONSTRUCTOR,

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

@@ -19,6 +19,8 @@ class AstRewriter {
 
   AstRewriter(this._errorReporter);
 
+  /// Possibly rewrites [node] as an [ExtensionOverride] or as an
+  /// [InstanceCreationExpression].
   AstNode methodInvocation(Scope nameScope, MethodInvocation node) {
     SimpleIdentifier methodName = node.methodName;
     if (methodName.isSynthetic) {
@@ -140,6 +142,44 @@ class AstRewriter {
     return node;
   }
 
+  /// Possibly rewrites [node] as a [ConstructorReference].
+  AstNode prefixedIdentifier(Scope nameScope, PrefixedIdentifier node) {
+    if (node.parent is Annotation) {
+      // An annotations which is a const constructor invocation can initially be
+      // represented with a [PrefixedIdentifier]. Do not rewrite such nodes.
+      return node;
+    }
+    if (node.parent is CommentReference) {
+      // TODO(srawlins): This probably should be rewritten to a
+      // [ConstructorReference] at some point.
+      return node;
+    }
+    var identifier = node.identifier;
+    if (identifier.isSynthetic) {
+      // This isn't a constructor reference.
+      return node;
+    }
+    var prefix = node.prefix;
+    var element = nameScope.lookup(prefix.name).getter;
+    if (element is ClassElement) {
+      // Example:
+      //     class C { C.named(); }
+      //     C.named
+      return _toConstructorReference(node: node, classElement: element);
+    } else if (element is TypeAliasElement) {
+      var aliasedType = element.aliasedType;
+      if (aliasedType is InterfaceType) {
+        // Example:
+        //     class C { C.named(); }
+        //     typedef X = C;
+        //     X.named
+        return _toConstructorReference(
+            node: node, classElement: aliasedType.element);
+      }
+    }
+    return node;
+  }
+
   AstNode _instanceCreation_prefix_type_name({
     required MethodInvocation node,
     required PrefixedIdentifier typeNameIdentifier,
@@ -170,6 +210,25 @@ class AstRewriter {
     return instanceCreationExpression;
   }
 
+  AstNode _toConstructorReference(
+      {required PrefixedIdentifier node, required ClassElement classElement}) {
+    var name = node.identifier.name;
+    var constructorElement = name == 'new'
+        ? classElement.unnamedConstructor
+        : classElement.getNamedConstructor(name);
+    if (constructorElement == null) {
+      return node;
+    }
+
+    var typeName = astFactory.typeName(node.prefix, null);
+    var constructorName =
+        astFactory.constructorName(typeName, node.period, node.identifier);
+    var constructorReference =
+        astFactory.constructorReference(constructorName: constructorName);
+    NodeReplacer.replace(node, constructorReference);
+    return constructorReference;
+  }
+
   InstanceCreationExpression _toInstanceCreation_prefix_type({
     required MethodInvocation node,
     required SimpleIdentifier prefixIdentifier,

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

@@ -0,0 +1,76 @@
+// Copyright (c) 2021, 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.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/element/member.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/resolver.dart';
+
+/// A resolver for [ConstructorReference] nodes.
+class ConstructorReferenceResolver {
+  /// The resolver driving this participant.
+  final ResolverVisitor _resolver;
+
+  ConstructorReferenceResolver(this._resolver);
+
+  void resolve(ConstructorReferenceImpl node) {
+    if (!_resolver.isConstructorTearoffsEnabled) {
+      _resolver.errorReporter.reportErrorForNode(
+          CompileTimeErrorCode.CONSTRUCTOR_TEAROFFS_NOT_ENABLED, node, []);
+    }
+    node.constructorName.accept(_resolver);
+    _inferArgumentTypes(node);
+  }
+
+  void _inferArgumentTypes(ConstructorReferenceImpl node) {
+    var constructorName = node.constructorName;
+    var typeName = constructorName.type;
+    var elementToInfer = _resolver.inferenceHelper.constructorElementToInfer(
+      constructorName: constructorName,
+      definingLibrary: _resolver.definingLibrary,
+    );
+
+    // If the constructor is generic, we'll have a ConstructorMember that
+    // substitutes in type arguments (possibly `dynamic`) from earlier in
+    // resolution.
+    //
+    // Otherwise we'll have a ConstructorElement, and we can skip inference
+    // because there's nothing to infer in a non-generic type.
+    if (elementToInfer != null) {
+      // TODO(leafp): Currently, we may re-infer types here, since we
+      // sometimes resolve multiple times.  We should really check that we
+      // have not already inferred something.  However, the obvious ways to
+      // check this don't work, since we may have been instantiated
+      // to bounds in an earlier phase, and we *do* want to do inference
+      // in that case.
+
+      // Get back to the uninstantiated generic constructor.
+      // TODO(jmesserly): should we store this earlier in resolution?
+      // Or look it up, instead of jumping backwards through the Member?
+      var rawElement = elementToInfer.element;
+      var constructorType = elementToInfer.asType;
+
+      var inferred = _resolver.inferenceHelper.inferTearOff(
+          node, constructorName.name!, constructorType) as FunctionType?;
+
+      if (inferred != null) {
+        typeName.type = inferred.returnType;
+
+        // Update the static element as well. This is used in some cases, such
+        // as computing constant values. It is stored in two places.
+        var constructorElement = ConstructorMember.from(
+          rawElement,
+          inferred.returnType as InterfaceType,
+        );
+        constructorName.staticElement = constructorElement;
+        constructorName.name?.staticElement = constructorElement;
+        node.staticType = inferred;
+      }
+    } else {
+      node.staticType = node.constructorName.staticElement!.type;
+    }
+  }
+}

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

@@ -128,6 +128,9 @@ class ExitDetector extends GeneralizingAstVisitor<bool> {
     return thenExpression.accept(this)! && elseExpression.accept(this)!;
   }
 
+  @override
+  bool visitConstructorReference(ConstructorReference node) => false;
+
   @override
   bool visitContinueStatement(ContinueStatement node) {
     _enclosingBlockContainsContinue = true;

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

@@ -50,7 +50,7 @@ class ConstructorElementToInfer {
       typeFormals: typeParameters,
       parameters: element.parameters,
       returnType: element.returnType,
-      nullabilitySuffix: NullabilitySuffix.star,
+      nullabilitySuffix: NullabilitySuffix.none,
     );
   }
 }

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

@@ -859,6 +859,16 @@ class ResolutionVisitor extends RecursiveAstVisitor<void> {
     super.visitPartOfDirective(node);
   }
 
+  @override
+  void visitPrefixedIdentifier(PrefixedIdentifier node) {
+    var newNode = _astRewriter.prefixedIdentifier(_nameScope, node);
+    if (newNode != node) {
+      return newNode.accept(this);
+    }
+
+    super.visitPrefixedIdentifier(node);
+  }
+
   @override
   void visitSimpleFormalParameter(covariant SimpleFormalParameterImpl node) {
     ParameterElementImpl element;

pkg/analyzer/lib/src/error/codes.dart

@@ -2262,6 +2262,23 @@ class CompileTimeErrorCode extends AnalyzerErrorCode {
           "Evaluation of this constant expression throws an "
               "IntegerDivisionByZeroException.");
 
+  /**
+   * A constructor cannot be torn off without the 'constructor-tearoffs'
+   * language feature.
+   *
+   * There is also a [ParserError.EXPERIMENT_NOT_ENABLED] code which catches
+   * some cases of constructor tearoff features (like `List<int>.filled;`).
+   * Other constructor tearoff cases are not realized until resolution
+   * (like `List.filled;`).
+   */
+  static const CompileTimeErrorCode CONSTRUCTOR_TEAROFFS_NOT_ENABLED =
+      CompileTimeErrorCode(
+          'CONSTRUCTOR_TEAROFFS_NOT_ENABLED',
+          "Tearing off a constructor requires the 'constructor-tearoffs' "
+              "language feature.",
+          correction: "Try updating your pubspec.yaml to set the minimum SDK "
+              "constraint to 2.14 or higher, and running 'pub get'.");
+
   /**
    * 16.12.2 Const: An expression of one of the forms !e, e1 && e2 or e1 || e2,
    * where e, e1 and e2 are constant expressions that evaluate to a boolean

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

@@ -31,6 +31,7 @@ import 'package:analyzer/src/dart/resolver/annotation_resolver.dart';
 import 'package:analyzer/src/dart/resolver/assignment_expression_resolver.dart';
 import 'package:analyzer/src/dart/resolver/binary_expression_resolver.dart';
 import 'package:analyzer/src/dart/resolver/body_inference_context.dart';
+import 'package:analyzer/src/dart/resolver/constructor_reference_resolver.dart';
 import 'package:analyzer/src/dart/resolver/extension_member_resolver.dart';
 import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/dart/resolver/for_resolver.dart';
@@ -186,6 +187,8 @@ class ResolverVisitor extends ScopedVisitor with ErrorDetectionHelpers {
 
   late final AssignmentExpressionResolver _assignmentExpressionResolver;
   late final BinaryExpressionResolver _binaryExpressionResolver;
+  late final ConstructorReferenceResolver _constructorReferenceResolver =
+      ConstructorReferenceResolver(this);
   late final FunctionExpressionInvocationResolver
       _functionExpressionInvocationResolver;
   late final FunctionExpressionResolver _functionExpressionResolver;
@@ -250,7 +253,8 @@ class ResolverVisitor extends ScopedVisitor with ErrorDetectionHelpers {
   late final FunctionReferenceResolver _functionReferenceResolver;
 
   late final InstanceCreationExpressionResolver
-      _instanceCreationExpressionResolver;
+      _instanceCreationExpressionResolver =
+      InstanceCreationExpressionResolver(this);
 
   /// Initialize a newly created visitor to resolve the nodes in an AST node.
   ///
@@ -372,8 +376,6 @@ class ResolverVisitor extends ScopedVisitor with ErrorDetectionHelpers {
     typeAnalyzer = StaticTypeAnalyzer(this, migrationResolutionHooks);
     _functionReferenceResolver =
         FunctionReferenceResolver(this, _isNonNullableByDefault);
-    _instanceCreationExpressionResolver =
-        InstanceCreationExpressionResolver(this);
   }
 
   bool get isConstructorTearoffsEnabled =>
@@ -1226,6 +1228,11 @@ class ResolverVisitor extends ScopedVisitor with ErrorDetectionHelpers {
     node.accept(typeAnalyzer);
   }
 
+  @override
+  void visitConstructorReference(covariant ConstructorReferenceImpl node) {
+    _constructorReferenceResolver.resolve(node);
+  }
+
   @override
   void visitContinueStatement(ContinueStatement node) {
     //

pkg/analyzer/lib/src/test_utilities/find_node.dart

@@ -92,6 +92,10 @@ class FindNode {
     return _node(search, (n) => n is ConstructorName);
   }
 
+  ConstructorReference constructorReference(String search) {
+    return _node(search, (n) => n is ConstructorReference);
+  }
+
   ContinueStatement continueStatement(String search) {
     return _node(search, (n) => n is ContinueStatement);
   }