[analyzer] Dot shorthands: Resolve DotShorthandPropertyAccess.

Allows the resolution of `.new` constructor references and static property accesses, using the existing `PropertyElementResolver` resolution logic.

Testing includes an AST builder test, and the `DotShorthandPropertyAccess` resolution tests. Some property access language tests are now passing.

Bug: #59835
Change-Id: Idb576ef7fa0866bc4b2d155bbf867886ae2b4df6
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/421964
Commit-Queue: Kallen Tu <[email protected]>
Reviewed-by: Chloe Stefantsova <[email protected]>

Author: kallentu

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer.dart

@@ -2332,6 +2332,10 @@ mixin TypeAnalyzer<
   /// Queries whether [node] is a dot shorthand.
   bool isDotShorthand(Expression node);
 
+  /// Queries whether the [_dotShorthands] stack is empty, meaning that we have
+  /// no cached context types.
+  bool get isDotShorthandContextEmpty => _dotShorthands.isEmpty;
+
   /// Queries whether the switch statement or expression represented by [node]
   /// was exhaustive.  [expressionType] is the static type of the scrutinee.
   ///

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

@@ -38,6 +38,44 @@ class PropertyElementResolver with ScopeHelpers {
 
   TypeSystemImpl get _typeSystem => _resolver.typeSystem;
 
+  PropertyElementResolverResult resolveDotShorthand(
+      DotShorthandPropertyAccessImpl node) {
+    if (_resolver.isDotShorthandContextEmpty) {
+      // TODO(kallentu): Produce an error here for not being able to find a
+      // context type.
+      return PropertyElementResolverResult();
+    }
+    TypeImpl context =
+        _resolver.getDotShorthandContext().unwrapTypeSchemaView();
+    // TODO(kallentu): Support other context types
+    if (context is InterfaceTypeImpl) {
+      var identifier = node.propertyName;
+      if (identifier.name == 'new') {
+        var element =
+            context.lookUpConstructor2(identifier.name, _definingLibrary);
+        if (element != null) {
+          return PropertyElementResolverResult(
+            readElementRequested2: element,
+            getType: element.returnType,
+          );
+        }
+      } else {
+        var contextElement = context.element3;
+        return _resolveTargetInterfaceElement(
+          typeReference: contextElement,
+          isCascaded: false,
+          propertyName: identifier,
+          hasRead: true,
+          hasWrite: false,
+        );
+      }
+    }
+
+    // TODO(kallentu): Produce an error here for not being able to find a
+    // property.
+    return PropertyElementResolverResult();
+  }
+
   PropertyElementResolverResult resolveIndexExpression({
     required IndexExpressionImpl node,
     required bool hasRead,

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -4093,8 +4093,12 @@ class AstBuilder extends StackListener {
     }
 
     var operand = pop() as ExpressionImpl;
-    // TODO(kallentu): Handle property access case.
-    if (operand is MethodInvocationImpl) {
+    if (operand is SimpleIdentifierImpl) {
+      push(DotShorthandPropertyAccessImpl(
+        period: periodToken,
+        propertyName: operand,
+      ));
+    } else if (operand is MethodInvocationImpl) {
       push(DotShorthandInvocationImpl(
         period: periodToken,
         memberName: operand.methodName,

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

@@ -5378,6 +5378,11 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
   /// [CompileTimeErrorCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER].
   void _checkForUnqualifiedReferenceToNonLocalStaticMember(
       SimpleIdentifier name) {
+    if (name.parent is DotShorthandPropertyAccessImpl ||
+        name.parent is DotShorthandInvocationImpl) {
+      return;
+    }
+
     var element = name.writeOrReadElement2;
     if (element == null || element is TypeParameterElement2) {
       return;

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

@@ -2315,9 +2315,26 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
   }
 
   @override
-  void visitDotShorthandPropertyAccess(DotShorthandPropertyAccess node,
+  void visitDotShorthandPropertyAccess(
+      covariant DotShorthandPropertyAccessImpl node,
       {TypeImpl contextType = UnknownInferredType.instance}) {
-    throw UnimplementedError('TODO(kallentu)');
+    inferenceLogWriter?.enterExpression(node, contextType);
+
+    // If [isDotShorthand] is set, cache the context type for resolution.
+    if (node.isDotShorthand) {
+      pushDotShorthandContext(SharedTypeSchemaView(contextType));
+    }
+
+    checkUnreachableNode(node);
+    var result = _propertyElementResolver.resolveDotShorthand(node);
+    _resolvePropertyAccessRhs_common(
+        result, node, node.propertyName, contextType);
+
+    if (node.isDotShorthand) {
+      popDotShorthandContext();
+    }
+
+    inferenceLogWriter?.exitExpression(node);
   }
 
   @override
@@ -3982,21 +3999,34 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
       hasWrite: false,
     );
 
-    var element = result.readElement2;
+    _resolvePropertyAccessRhs_common(
+        result, node, node.propertyName, contextType);
+    nullSafetyDeadCodeVerifier.verifyPropertyAccess(node);
+  }
+
+  /// Common logic for resolving dot shorthands property accesses and
+  /// [_resolvePropertyAccessRhs].
+  void _resolvePropertyAccessRhs_common(
+      PropertyElementResolverResult resolverResult,
+      ExpressionImpl node,
+      SimpleIdentifierImpl propertyName,
+      TypeImpl contextType) {
+    var element = resolverResult.readElement2;
 
-    var propertyName = node.propertyName;
     propertyName.element = element;
 
     DartType type;
     if (element is MethodElement2) {
       type = element.type;
+    } else if (element is ConstructorElementImpl2) {
+      type = element.type;
     } else if (element is GetterElement) {
-      type = result.getType!;
-    } else if (result.functionTypeCallType != null) {
-      type = result.functionTypeCallType!;
-    } else if (result.recordField != null) {
-      type = result.recordField!.type;
-    } else if (result.atDynamicTarget) {
+      type = resolverResult.getType!;
+    } else if (resolverResult.functionTypeCallType != null) {
+      type = resolverResult.functionTypeCallType!;
+    } else if (resolverResult.recordField != null) {
+      type = resolverResult.recordField!.type;
+    } else if (resolverResult.atDynamicTarget) {
       type = DynamicTypeImpl.instance;
     } else {
       type = InvalidTypeImpl.instance;
@@ -4020,7 +4050,6 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
 
     nullShortingTermination(node, rewrittenExpression: replacement);
     _insertImplicitCallReference(replacement, contextType: contextType);
-    nullSafetyDeadCodeVerifier.verifyPropertyAccess(node);
   }
 
   /// Continues resolution of a [FunctionExpressionInvocation] that was created

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

@@ -61,6 +61,8 @@ class FindNode {
 
   DotShorthandInvocation get singleDotShorthandInvocation => _single();
 
+  DotShorthandPropertyAccess get singleDotShorthandPropertyAccess => _single();
+
   EnumDeclaration get singleEnumDeclaration => _single();
 
   ExportDirective get singleExportDirective => _single();
@@ -366,6 +368,10 @@ class FindNode {
     return _node(search, (n) => n is DotShorthandInvocation);
   }
 
+  DotShorthandPropertyAccess dotShorthandPropertyAccess(String search) {
+    return _node(search, (n) => n is DotShorthandPropertyAccess);
+  }
+
   DoubleLiteral doubleLiteral(String search) {
     return _node(search, (n) => n is DoubleLiteral);
   }

pkg/analyzer/test/src/dart/resolution/dot_shorthand_property_access_test.dart

@@ -0,0 +1,87 @@
+// Copyright (c) 2025, 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:test_reflective_loader/test_reflective_loader.dart';
+
+import 'context_collection_resolution.dart';
+import 'node_text_expectations.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(DotShorthandPropertyAccessResolutionTest);
+    defineReflectiveTests(UpdateNodeTextExpectations);
+  });
+}
+
+@reflectiveTest
+class DotShorthandPropertyAccessResolutionTest
+    extends PubPackageResolutionTest {
+  test_class_basic() async {
+    await assertNoErrorsInCode('''
+class C {
+  static C get member => C(1);
+  int x;
+  C(this.x);
+}
+
+void main() {
+  C c = .member;
+  print(c);
+}
+''');
+
+    var identifier = findNode.singleDotShorthandPropertyAccess;
+    assertResolvedNodeText(identifier, r'''
+DotShorthandPropertyAccess
+  period: .
+  propertyName: SimpleIdentifier
+    token: member
+    element: <testLibraryFragment>::@class::C::@getter::member#element
+    staticType: C
+  staticType: C
+''');
+  }
+
+  test_enum_basic() async {
+    await assertNoErrorsInCode('''
+enum C { red }
+
+void main() {
+  C c = .red;
+  print(c);
+}
+''');
+
+    var identifier = findNode.singleDotShorthandPropertyAccess;
+    assertResolvedNodeText(identifier, r'''
+DotShorthandPropertyAccess
+  period: .
+  propertyName: SimpleIdentifier
+    token: red
+    element: <testLibraryFragment>::@enum::C::@getter::red#element
+    staticType: C
+  staticType: C
+''');
+  }
+
+  test_object_new() async {
+    await assertNoErrorsInCode('''
+void main() {
+  Object o = .new;
+  print(o);
+}
+''');
+
+    var identifier = findNode.singleDotShorthandPropertyAccess;
+    assertResolvedNodeText(identifier, r'''
+DotShorthandPropertyAccess
+  period: .
+  propertyName: SimpleIdentifier
+    token: new
+    element: dart:core::<fragment>::@class::Object::@constructor::new#element
+    staticType: Object Function()
+  staticType: Object Function()
+''');
+  }
+}

pkg/analyzer/test/src/dart/resolution/test_all.dart

@@ -27,6 +27,8 @@ import 'constructor_reference_test.dart' as constructor_reference;
 import 'constructor_test.dart' as constructor;
 import 'declared_variable_pattern_test.dart' as declared_variable_pattern;
 import 'dot_shorthand_invocation_test.dart' as dot_shorthand_invocation;
+import 'dot_shorthand_property_access_test.dart'
+    as dot_shorthand_property_access;
 import 'enum_test.dart' as enum_resolution;
 import 'extension_method_test.dart' as extension_method;
 import 'extension_override_test.dart' as extension_override;
@@ -141,6 +143,7 @@ main() {
     constructor.main();
     declared_variable_pattern.main();
     dot_shorthand_invocation.main();
+    dot_shorthand_property_access.main();
     enum_resolution.main();
     extension_method.main();
     extension_override.main();

pkg/analyzer/test/src/fasta/ast_builder_test.dart

@@ -925,6 +925,25 @@ DotShorthandInvocation
 ''');
   }
 
+  void test_dotShorthand_propertyAccess() {
+    var parseResult = parseStringWithErrors(r'''
+enum E { a }
+
+void main() {
+  E e = .a;
+}
+''');
+    parseResult.assertNoErrors();
+
+    var node = parseResult.findNode.dotShorthandPropertyAccess('.a');
+    assertParsedNodeText(node, r'''
+DotShorthandPropertyAccess
+  period: .
+  propertyName: SimpleIdentifier
+    token: a
+''');
+  }
+
   void test_enum_base() {
     var parseResult = parseStringWithErrors(r'''
 base enum E { v }

pkg/analyzer/test/src/summary/resolved_ast_printer.dart

@@ -477,6 +477,16 @@ class ResolvedAstPrinter extends ThrowingAstVisitor<void> {
     });
   }
 
+  @override
+  void visitDotShorthandPropertyAccess(DotShorthandPropertyAccess node) {
+    _sink.writeln('DotShorthandPropertyAccess');
+    _sink.withIndent(() {
+      _writeNamedChildEntities(node);
+      _writeParameterElement(node);
+      _writeType('staticType', node.staticType);
+    });
+  }
+
   @override
   void visitDottedName(DottedName node) {
     _sink.writeln('DottedName');