Version 2.15.0-268.8.beta

* Cherry-pick 243fb5c to beta
* Cherry-pick 1ca06b9 to beta
* Cherry-pick b8e419d to beta
* Cherry-pick dc7e082 to beta
* Cherry-pick 6225f46 to beta
* Cherry-pick b97737c to beta
* Cherry-pick 109c317 to beta

Author: athomas

CHANGELOG.md

@@ -429,9 +429,12 @@
 
 #### `dart:js_util`
 
-- The `js_util` methods `getProperty`, `setProperty`, `callMethod`,
-  `callConstructor`, and `newObject` now support a generic type argument
-  to specify the return type.
+- The `js_util` methods `setProperty`, `callMethod`, and `callConstructor` have
+  been optimized to remove checks on arguments when the checks can be elided.
+  Also, those methods, along with `getProperty` and `newObject`, now support a
+  generic type argument to specify a return type. These two changes make simple
+  `js_util` usage, like reading and writing primitive properties or calling
+  methods with simple arguments, have zero overhead.
 
 #### `dart:web_sql`
 
@@ -592,6 +595,14 @@ This feature requires
   `dart pub get/upgrade/downgrade/add/remove` that will result in the `example/`
   folder dependencies to be updated after operating in the current directory.
 
+### Other libraries
+
+#### `package:js`
+
+- Extensions on JS interop or native `dart:html` classes can now declare
+  members as `external`. These members are equivalent to regular extension
+  members that use `js_util` to expose the underlying JavaScript.
+
 ## 2.14.4 - 2021-10-14
 
 This is a patch release that fixes:

DEPS

@@ -107,7 +107,7 @@ vars = {
   "dart_style_rev": "08b0294d0a500d5c02168ef57dcb8868d0c3cb48",
 
   "dartdoc_rev" : "520e64977de7a87b2fd5be56e5c2e1a58d55bdad",
-  "devtools_rev" : "8881a7caa9067471008a8e00750b161f53cdb843",
+  "devtools_rev" : "3a2f570813200e6dee141f3e7a9edcae5f31c2e8",
   "jsshell_tag": "version:88.0",
   "ffi_rev": "4dd32429880a57b64edaf54c9d5af8a9fa9a4ffb",
   "fixnum_rev": "16d3890c6dc82ca629659da1934e412292508bba",
@@ -139,7 +139,7 @@ vars = {
   "pool_rev": "7abe634002a1ba8a0928eded086062f1307ccfae",
   "process_rev": "56ece43b53b64c63ae51ec184b76bd5360c28d0b",
   "protobuf_rev": "c1eb6cb51af39ccbaa1a8e19349546586a5c8e31",
-  "pub_rev": "0035a40f25d027130c0314571da53ffafc6d973b",
+  "pub_rev": "96404e0749864c9fbf8b12e1d424e8078809e00a",
   "pub_semver_rev": "a43ad72fb6b7869607581b5fedcb186d1e74276a",
   "root_certificates_rev": "692f6d6488af68e0121317a9c2c9eb393eb0ee50",
   "rust_revision": "b7856f695d65a8ebc846754f97d15814bcb1c244",

pkg/analyzer/lib/src/dart/constant/evaluation.dart

@@ -632,39 +632,31 @@ class ConstantVisitor extends UnifyingAstVisitor<DartObjectImpl> {
 
   @override
   DartObjectImpl? visitConstructorReference(ConstructorReference node) {
-    var constructorTearoffResult = DartObjectImpl(
+    var constructorFunctionType = node.typeOrThrow as FunctionType;
+    var classType = constructorFunctionType.returnType as InterfaceType;
+    var typeArguments = classType.typeArguments;
+    // The result is already instantiated during resolution;
+    // [_dartObjectComputer.typeInstantiate] is unnecessary.
+    var typeElement =
+        node.constructorName.type2.name.staticElement as TypeDefiningElement;
+
+    TypeAliasElement? viaTypeAlias;
+    if (typeElement is TypeAliasElementImpl) {
+      if (constructorFunctionType.typeFormals.isNotEmpty &&
+          !typeElement.isProperRename()) {
+        // The type alias is not a proper rename of the aliased class, so
+        // the constructor tear-off is distinct from the associated
+        // constructor function of the aliased class.
+        viaTypeAlias = typeElement;
+      }
+    }
+
+    return DartObjectImpl(
       typeSystem,
       node.typeOrThrow,
-      FunctionState(node.constructorName.staticElement),
+      FunctionState(node.constructorName.staticElement,
+          typeArguments: typeArguments, viaTypeAlias: viaTypeAlias),
     );
-    var typeArgumentList = node.constructorName.type2.typeArguments;
-    if (typeArgumentList == null) {
-      return constructorTearoffResult;
-    } else {
-      var typeArguments = <DartType>[];
-      for (var typeArgument in typeArgumentList.arguments) {
-        var object = typeArgument.accept(this);
-        if (object == null) {
-          return null;
-        }
-        var typeArgumentType = object.toTypeValue();
-        if (typeArgumentType == null) {
-          return null;
-        }
-        // TODO(srawlins): Test type alias types (`typedef i = int`) used as
-        // type arguments. Possibly change implementation based on
-        // canonicalization rules.
-        typeArguments.add(typeArgumentType);
-      }
-      // The result is already instantiated during resolution;
-      // [_dartObjectComputer.typeInstantiate] is unnecessary.
-      return DartObjectImpl(
-        typeSystem,
-        node.typeOrThrow,
-        FunctionState(node.constructorName.staticElement,
-            typeArguments: typeArguments),
-      );
-    }
   }
 
   @override

pkg/analyzer/lib/src/dart/constant/value.dart

@@ -920,11 +920,14 @@ class DartObjectImpl implements DartObject {
     List<DartType> typeArguments,
   ) {
     var functionState = _state as FunctionState;
-    var element = functionState._element;
     return DartObjectImpl(
       typeSystem,
       type,
-      FunctionState(element, typeArguments: typeArguments),
+      FunctionState(
+        functionState._element,
+        typeArguments: typeArguments,
+        viaTypeAlias: functionState._viaTypeAlias,
+      ),
     );
   }
 
@@ -1245,10 +1248,22 @@ class FunctionState extends InstanceState {
 
   final List<DartType>? _typeArguments;
 
+  /// The type alias which was referenced when tearing off a constructor,
+  /// if this function is a constructor tear-off, referenced via a type alias,
+  /// and the type alias is not a proper rename for the class, and the
+  /// constructor tear-off is generic, so the tear-off cannot be considered
+  /// equivalent to tearing off the associated constructor function of the
+  /// aliased class.
+  ///
+  /// Otherwise null.
+  final TypeDefiningElement? _viaTypeAlias;
+
   /// Initialize a newly created state to represent the function with the given
   /// [element].
-  FunctionState(this._element, {List<DartType>? typeArguments})
-      : _typeArguments = typeArguments;
+  FunctionState(this._element,
+      {List<DartType>? typeArguments, TypeDefiningElement? viaTypeAlias})
+      : _typeArguments = typeArguments,
+        _viaTypeAlias = viaTypeAlias;
 
   @override
   int get hashCode => _element == null ? 0 : _element.hashCode;
@@ -1272,6 +1287,9 @@ class FunctionState extends InstanceState {
     if (typeArguments.length != otherTypeArguments.length) {
       return false;
     }
+    if (_viaTypeAlias != object._viaTypeAlias) {
+      return false;
+    }
     for (var i = 0; i < typeArguments.length; i++) {
       if (typeArguments[i] != otherTypeArguments[i]) {
         return false;
@@ -1309,6 +1327,9 @@ class FunctionState extends InstanceState {
       if (element?.declaration != otherElement?.declaration) {
         return BoolState.FALSE_STATE;
       }
+      if (_viaTypeAlias != rightOperand._viaTypeAlias) {
+        return BoolState.FALSE_STATE;
+      }
       var typeArguments = _typeArguments;
       var otherTypeArguments = rightOperand._typeArguments;
       if (typeArguments == null || otherTypeArguments == null) {

pkg/analyzer/lib/src/dart/element/element.dart

@@ -5582,6 +5582,37 @@ class TypeAliasElementImpl extends _ExistingElementImpl
     }
   }
 
+  /// Returns whether this alias is a "proper rename" of [aliasedClass], as
+  /// defined in the constructor-tearoffs specification.
+  bool isProperRename() {
+    var aliasedType_ = aliasedType;
+    if (aliasedType_ is! InterfaceType) {
+      return false;
+    }
+    var aliasedClass = aliasedType_.element;
+    var typeArguments = aliasedType_.typeArguments;
+    var typeParameterCount = typeParameters.length;
+    if (typeParameterCount != aliasedClass.typeParameters.length) {
+      return false;
+    }
+    if (typeParameterCount != typeArguments.length) {
+      return false;
+    }
+    for (var i = 0; i < typeParameterCount; i++) {
+      var bound = typeParameters[i].bound ?? library.typeProvider.dynamicType;
+      var aliasedBound = aliasedClass.typeParameters[i].bound ??
+          library.typeProvider.dynamicType;
+      if (!library.typeSystem.isSubtypeOf(bound, aliasedBound) ||
+          !library.typeSystem.isSubtypeOf(aliasedBound, bound)) {
+        return false;
+      }
+      if (typeParameters[i] != typeArguments[i].element) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   void setLinkedData(Reference reference, ElementLinkedData linkedData) {
     this.reference = reference;
     reference.element = this;

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

@@ -123,6 +123,7 @@ class ConstructorReferenceResolver {
         constructorName.staticElement = constructorElement.declaration;
         constructorName.name?.staticElement = constructorElement.declaration;
         node.staticType = inferred;
+        // The NamedType child of `constructorName` doesn't have a static type.
         constructorName.type2.type = null;
       }
     } else {
@@ -132,6 +133,7 @@ class ConstructorReferenceResolver {
       } else {
         node.staticType = constructorElement.type;
       }
+      // The NamedType child of `constructorName` doesn't have a static type.
       constructorName.type2.type = null;
     }
   }

pkg/analyzer/test/src/dart/constant/evaluation_test.dart

@@ -28,6 +28,126 @@ main() {
 @reflectiveTest
 class ConstantVisitorTest extends ConstantVisitorTestSupport
     with ConstantVisitorTestCases {
+  test_identical_constructorReference_aliasIsNotGeneric() async {
+    await resolveTestCode('''
+class C<T> {}
+typedef MyC = C<int>;
+const a = identical(MyC.new, C<int>.new);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(true),
+    );
+  }
+
+  test_identical_constructorReference_aliasIsNotProperRename_differentBound() async {
+    await resolveTestCode('''
+class C<T> {}
+typedef MyC<T extends num> = C<T>;
+const a = identical(MyC.new, C.new);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(false),
+    );
+  }
+
+  test_identical_constructorReference_aliasIsNotProperRename_differentCount() async {
+    await resolveTestCode('''
+class C<T, U> {}
+typedef MyC<T> = C<T, int>;
+const a = identical(MyC.new, C.new);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(false),
+    );
+  }
+
+  test_identical_constructorReference_aliasIsNotProperRename_differentOrder() async {
+    await resolveTestCode('''
+class C<T, U> {}
+typedef MyC<T, U> = C<U, T>;
+const a = identical(MyC.new, C.new);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(false),
+    );
+  }
+
+  test_identical_constructorReference_aliasIsNotProperRename_instantiated() async {
+    await resolveTestCode('''
+class C<T> {}
+typedef MyC<T extends num> = C<T>;
+const a = identical(MyC<int>.new, C<int>.new);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(true),
+    );
+  }
+
+  test_identical_constructorReference_aliasIsNotProperRename_mixedInstantiations() async {
+    await resolveTestCode('''
+class C<T> {}
+typedef MyC<T extends num> = C<T>;
+const a = identical(MyC<int>.new, (MyC.new)<int>);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(false),
+    );
+  }
+
+  test_identical_constructorReference_aliasIsProperRename_instantiated() async {
+    await resolveTestCode('''
+class C<T> {}
+typedef MyC<T> = C<T>;
+const a = identical(MyC<int>.new, MyC<int>.new);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(true),
+    );
+  }
+
+  test_identical_constructorReference_aliasIsProperRename_mixedInstantiations() async {
+    await resolveTestCode('''
+class C<T> {}
+typedef MyC<T> = C<T>;
+const a = identical(MyC<int>.new, (MyC.new)<int>);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(true),
+    );
+  }
+
+  test_identical_constructorReference_aliasIsProperRename_mutualSubtypes() async {
+    await resolveTestCode('''
+class C<T> {}
+typedef MyC<T extends Object?> = C<T>;
+const a = identical(MyC<int>.new, MyC<int>.new);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(true),
+    );
+  }
+
+  test_identical_constructorReference_aliasIsProperRename_uninstantiated() async {
+    await resolveTestCode('''
+class C<T> {}
+typedef MyC<T> = C<T>;
+const a = identical(MyC.new, MyC.new);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(true),
+    );
+  }
+
   test_identical_constructorReference_explicitTypeArgs_differentClasses() async {
     await resolveTestCode('''
 class C<T> {}
@@ -76,6 +196,19 @@ const a = identical(C<int>.new, C<int>.new);
     );
   }
 
+  test_identical_constructorReference_inferredTypeArgs_sameElement() async {
+    await resolveTestCode('''
+class C<T> {}
+const C<int> Function() c1 = C.new;
+const c2 = C<int>.new;
+const a = identical(c1, c2);
+''');
+    expect(
+      _evaluateConstant('a'),
+      _boolValue(true),
+    );
+  }
+
   test_identical_constructorReference_notInstantiated_differentClasses() async {
     await resolveTestCode('''
 class C<T> {}