Front end: Fix field promotion for extension type representation variable.

Update the type inference algorithm so that `FlowAnalysis.propertyGet`
is appropriately called when analyzing code that refers to the
representation variable of an extension type.

Flow analysis requires an arbitrary `Object` to represent the property
in question; this is later passed to
`OperationsCfe.isPropertyPromotable`. We use the synthetic
"representation field" (which is actually a `Procedure`) for this
purpose
(`ExtensionTypeRepresentationAccessTarget.representationField`).

Representation variables are considered promotable if they are public
(see
dart-lang/language#3411). `OperationsCfe.isPropertyPromotable`
can tell if the representation variable is public by checking the name
of the synthetic representation field.

Fixes #53439.

Bug: #53439
Change-Id: I8f7ff8fcd8e5a43de419b8441951b52a555fda1a
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/332480
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Chloe Stefantsova <[email protected]>

Author: stereotype441

pkg/front_end/lib/src/fasta/source/source_library_builder.dart

@@ -1682,6 +1682,13 @@ class SourceLibraryBuilder extends LibraryBuilderImpl {
     while (extensionTypeIterator.moveNext()) {
       SourceExtensionTypeDeclarationBuilder extensionType =
           extensionTypeIterator.current;
+      Member? representationGetter =
+          extensionType.representationFieldBuilder?.readTarget;
+      if (representationGetter != null &&
+          !representationGetter.name.isPrivate) {
+        individualPropertyReasons[representationGetter] =
+            PropertyNonPromotabilityReason.isNotPrivate;
+      }
       for (Builder member in extensionType.scope.localMembers) {
         if (member is SourceProcedureBuilder &&
             !member.isStatic &&

pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart

@@ -6690,7 +6690,9 @@ class InferenceVisitorImpl extends InferenceVisitorBase
         propertyGetNode,
         computePropertyTarget(receiver),
         propertyName.text,
-        readTarget.member,
+        readTarget is ExtensionTypeRepresentationAccessTarget
+            ? readTarget.representationField
+            : readTarget.member,
         readType);
     return createPropertyGet(
         fileOffset: fileOffset,

pkg/front_end/lib/src/fasta/type_inference/inference_visitor_base.dart

@@ -3401,6 +3401,14 @@ abstract class InferenceVisitorBase implements InferenceVisitor {
       case ObjectAccessTargetKind.extensionTypeRepresentation:
       case ObjectAccessTargetKind.nullableExtensionTypeRepresentation:
         DartType type = target.getGetterType(this);
+        type = flowAnalysis.propertyGet(
+                null,
+                computePropertyTarget(receiver),
+                name.text,
+                (target as ExtensionTypeRepresentationAccessTarget)
+                    .representationField,
+                type) ??
+            type;
         Expression read = new AsExpression(receiver, type)
           ..isForNonNullableByDefault = true
           ..isUnchecked = true

pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart

@@ -525,6 +525,10 @@ class OperationsCfe
       return false;
     }
     if (property is Procedure) {
+      if (property.stubKind == ProcedureStubKind.RepresentationField) {
+        // Representation fields are promotable if they're non-public.
+        return property.name.isPrivate;
+      }
       if (!property.isAccessor) {
         // We don't promote methods.
         return false;

tests/language/extension_type/field_promotion_representation_cascaded_nullable_test.dart

@@ -0,0 +1,36 @@
+// Copyright (c) 2023, 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.
+
+// Tests that field promotion of the representation variable works properly in
+// cascade expressions.
+//
+// These tests specifically exercise extension types whose representation type
+// is nullable, since those are handled differently by the front end than
+// extension types whose representation type is non-nullable.
+
+// SharedOptions=--enable-experiment=inline-class
+
+import '../static_type_helper.dart';
+
+extension type E(Object Function()? _f) {
+  testExplicitThisAccess() {
+    if (this._f != null) {
+      this.._f.expectStaticType<Exactly<Object Function()>>();
+      this.._f().expectStaticType<Exactly<Object>>();
+    }
+  }
+}
+
+testGeneralPropertyAccess(E e) {
+  if (e._f != null) {
+    e.._f.expectStaticType<Exactly<Object Function()>>();
+    e.._f().expectStaticType<Exactly<Object>>();
+  }
+}
+
+main() {
+  int Function() f = () => 0;
+  E(f).testExplicitThisAccess();
+  testGeneralPropertyAccess(E(f));
+}

tests/language/extension_type/field_promotion_representation_cascaded_test.dart

@@ -0,0 +1,32 @@
+// Copyright (c) 2023, 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.
+
+// Tests that field promotion of the representation variable works properly in
+// cascade expressions.
+
+// SharedOptions=--enable-experiment=inline-class
+
+import '../static_type_helper.dart';
+
+extension type E(Object Function() _f) {
+  testExplicitThisAccess() {
+    if (this._f is int Function()) {
+      this.._f.expectStaticType<Exactly<int Function()>>();
+      this.._f().expectStaticType<Exactly<int>>();
+    }
+  }
+}
+
+testGeneralPropertyAccess(E e) {
+  if (e._f is int Function()) {
+    e.._f.expectStaticType<Exactly<int Function()>>();
+    e.._f().expectStaticType<Exactly<int>>();
+  }
+}
+
+main() {
+  int Function() f = () => 0;
+  E(f).testExplicitThisAccess();
+  testGeneralPropertyAccess(E(f));
+}

tests/language/extension_type/field_promotion_representation_conflicts_test.dart

@@ -0,0 +1,65 @@
+// Copyright (c) 2023, 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.
+
+// Tests that if the representation variable has the same name as other
+// non-promotable things in the file, it may nonetheless undergo field promotion
+// (this is sound because extension types are resolved statically, so there is
+// no danger of the representation variable aliasing to some other declaration,
+// as there is for ordinary fields).
+
+// SharedOptions=--enable-experiment=inline-class
+
+import '../static_type_helper.dart';
+
+class C1 {
+  int? _f = 0;
+}
+
+class C2 {
+  int? get _f => 0;
+}
+
+class C3 implements C2 {
+  noSuchMethod(invocation) => 0;
+}
+
+extension type E(Object Function() _f) {
+  testImplicitThisAccess() {
+    if (_f is int Function()) {
+      _f.expectStaticType<Exactly<int Function()>>();
+      _f().expectStaticType<Exactly<int>>();
+    }
+  }
+
+  testExplicitThisAccess() {
+    if (this._f is int Function()) {
+      this._f.expectStaticType<Exactly<int Function()>>();
+      this._f().expectStaticType<Exactly<int>>();
+    }
+  }
+}
+
+testGeneralPropertyAccess(E e) {
+  if ((e)._f is int Function()) {
+    (e)._f.expectStaticType<Exactly<int Function()>>();
+    (e)._f().expectStaticType<Exactly<int>>();
+  }
+}
+
+testPrefixedIdentifierAccess(E e) {
+  // Note: the analyzer has a special representation for property accesses of
+  // the form `IDENTIFIER.IDENTIFIER`, so we test this form separately.
+  if (e._f is int Function()) {
+    e._f.expectStaticType<Exactly<int Function()>>();
+    e._f().expectStaticType<Exactly<int>>();
+  }
+}
+
+main() {
+  int Function() f = () => 0;
+  E(f).testImplicitThisAccess();
+  E(f).testExplicitThisAccess();
+  testGeneralPropertyAccess(E(f));
+  testPrefixedIdentifierAccess(E(f));
+}

tests/language/extension_type/field_promotion_representation_independent_of_extension_type_test.dart

@@ -0,0 +1,52 @@
+// Copyright (c) 2023, 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.
+
+// Tests that flow analysis treats representation variables as independent of
+// extension type objects. That is, if `e` is a promotable expression whose type
+// is an extension type, and its representation variable is `_f`, null checks
+// and `is` tests applied to `e` should not affect the type of `e._f`.
+//
+// SharedOptions=--enable-experiment=inline-class
+
+import '../static_type_helper.dart';
+
+extension type E(Object Function() _f) {
+  testImplicitThisAccess() {
+    if (this is int Function()) {
+      _f.expectStaticType<Exactly<Object Function()>>();
+      _f().expectStaticType<Exactly<Object>>();
+    }
+  }
+
+  testExplicitThisAccess() {
+    if (this._f is Object Function()) {
+      this._f.expectStaticType<Exactly<Object Function()>>();
+      this._f().expectStaticType<Exactly<Object>>();
+    }
+  }
+}
+
+testGeneralPropertyAccess(E e) {
+  if (e is int Function()) {
+    (e)._f.expectStaticType<Exactly<Object Function()>>();
+    (e)._f().expectStaticType<Exactly<Object>>();
+  }
+}
+
+testPrefixedIdentifierAccess(E e) {
+  // Note: the analyzer has a special representation for property accesses of
+  // the form `IDENTIFIER.IDENTIFIER`, so we test this form separately.
+  if (e is int Function()) {
+    e._f.expectStaticType<Exactly<Object Function()>>();
+    e._f().expectStaticType<Exactly<Object>>();
+  }
+}
+
+main() {
+  int Function() f = () => 0;
+  E(f).testImplicitThisAccess();
+  E(f).testExplicitThisAccess();
+  testGeneralPropertyAccess(E(f));
+  testPrefixedIdentifierAccess(E(f));
+}

tests/language/extension_type/field_promotion_representation_interference_test.dart

@@ -0,0 +1,28 @@
+// Copyright (c) 2023, 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.
+
+// Tests that the presence of a representation variable with a given name
+// doesn't interfere with promotability of fields having the same name elsewhere
+// in the library.
+
+// SharedOptions=--enable-experiment=inline-class
+
+import '../static_type_helper.dart';
+
+extension type E(int? _field) {}
+
+class C {
+  final int? _field;
+  C(this._field);
+}
+
+test(C c) {
+  if (c._field != null) {
+    c._field.expectStaticType<Exactly<int>>();
+  }
+}
+
+main() {
+  test(C(0));
+}

tests/language/extension_type/field_promotion_representation_nullable_test.dart

@@ -0,0 +1,54 @@
+// Copyright (c) 2023, 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.
+
+// Tests that the representation variable may undergo field promotion, assuming
+// that it's private.
+//
+// These tests specifically exercise extension types whose representation type
+// is nullable, since those are handled differently by the front end than
+// extension types whose representation type is non-nullable.
+
+// SharedOptions=--enable-experiment=inline-class
+
+import '../static_type_helper.dart';
+
+extension type E(Object Function()? _f) {
+  testImplicitThisAccess() {
+    if (_f != null) {
+      _f.expectStaticType<Exactly<Object Function()>>();
+      _f().expectStaticType<Exactly<Object>>();
+    }
+  }
+
+  testExplicitThisAccess() {
+    if (this._f != null) {
+      this._f.expectStaticType<Exactly<Object Function()>>();
+      this._f().expectStaticType<Exactly<Object>>();
+    }
+  }
+}
+
+testGeneralPropertyAccess(E e) {
+  if ((e)._f != null) {
+    (e)._f.expectStaticType<Exactly<Object Function()>>();
+    (e)._f().expectStaticType<Exactly<Object>>();
+  }
+}
+
+testPrefixedIdentifierAccess(E e) {
+  // Note: the analyzer has a special representation for property accesses of
+  // the form `IDENTIFIER.IDENTIFIER`, so we test this form separately.
+  if (e._f != null) {
+    e._f.expectStaticType<Exactly<Object Function()>>();
+    e._f().expectStaticType<Exactly<Object>>();
+  }
+}
+
+main() {
+  int Function() f = () => 0;
+  E(f).testImplicitThisAccess();
+  E(f).testExplicitThisAccess();
+  testGeneralPropertyAccess(E(f));
+  testPrefixedIdentifierAccess(E(f));
+}

tests/language/extension_type/field_promotion_representation_private_test.dart

@@ -0,0 +1,50 @@
+// Copyright (c) 2023, 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.
+
+// Tests that the representation variable may undergo field promotion, assuming
+// that it's private.
+
+// SharedOptions=--enable-experiment=inline-class
+
+import '../static_type_helper.dart';
+
+extension type E(Object Function() _f) {
+  testImplicitThisAccess() {
+    if (_f is int Function()) {
+      _f.expectStaticType<Exactly<int Function()>>();
+      _f().expectStaticType<Exactly<int>>();
+    }
+  }
+
+  testExplicitThisAccess() {
+    if (this._f is int Function()) {
+      this._f.expectStaticType<Exactly<int Function()>>();
+      this._f().expectStaticType<Exactly<int>>();
+    }
+  }
+}
+
+testGeneralPropertyAccess(E e) {
+  if ((e)._f is int Function()) {
+    (e)._f.expectStaticType<Exactly<int Function()>>();
+    (e)._f().expectStaticType<Exactly<int>>();
+  }
+}
+
+testPrefixedIdentifierAccess(E e) {
+  // Note: the analyzer has a special representation for property accesses of
+  // the form `IDENTIFIER.IDENTIFIER`, so we test this form separately.
+  if (e._f is int Function()) {
+    e._f.expectStaticType<Exactly<int Function()>>();
+    e._f().expectStaticType<Exactly<int>>();
+  }
+}
+
+main() {
+  int Function() f = () => 0;
+  E(f).testImplicitThisAccess();
+  E(f).testExplicitThisAccess();
+  testGeneralPropertyAccess(E(f));
+  testPrefixedIdentifierAccess(E(f));
+}