Version 2.14.0-390.0.dev

Merge commit '0b1ddaa598d4fcc2fdf2eb750623d30326191d46' into 'dev'

Author: Dart CI

CHANGELOG.md

@@ -82,6 +82,7 @@
 - `convertNativeToDart_Dictionary()` now converts objects recursively, this
   fixes APIs like MediaStreamTrack.getCapabilities that convert between Maps and
   browser Dictionaries. [#44319]
+- Added some access-control HTTP header names to `HttpHeaders`.
 
 [#44319]: https://github.com/dart-lang/sdk/issues/44319
 
@@ -90,6 +91,7 @@
 - BREAKING CHANGE (for pre-migrated null safe code): `HttpClient`'s
   `.authenticate` and `.authenticateProxy` setter callbacks must now accept a
   nullable `realm` argument.
+- Added some access-control HTTP header names to `HttpHeaders`.
 
 #### `dart:typed_data`
 

benchmarks/IsolateFibonacci/dart/IsolateFibonacci.dart

@@ -0,0 +1,66 @@
+// 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 'dart:async';
+import 'dart:io';
+import 'dart:isolate';
+import 'dart:math';
+
+import 'package:expect/expect.dart';
+
+// Implements recursive summation via tail calls:
+//   fib(n) => n <= 1 ? 1
+//                    : fib(n-1) + fib(n-2);
+Future fibonacciRecursive(List args) async {
+  final SendPort port = args[0];
+  final n = args[1];
+  if (n <= 1) {
+    port.send(1);
+    return;
+  }
+  final left = ReceivePort();
+  final right = ReceivePort();
+  await Future.wait([
+    Isolate.spawn(fibonacciRecursive, [left.sendPort, n - 1]),
+    Isolate.spawn(fibonacciRecursive, [right.sendPort, n - 2]),
+  ]);
+  final results = await Future.wait([left.first, right.first]);
+  port.send(results[0] + results[1]);
+}
+
+Future<void> main() async {
+  final rpWarmup = ReceivePort();
+  final rpRun = ReceivePort();
+  final int nWarmup = 17; // enough runs to trigger optimized compilation
+  final int nWarmupFactorial = 2584;
+  // With --enable-isolate-groups runs for about 8 seconds.
+  // Should not be run witout --enable-isolate-groups as it would be too slow.
+  final int n = 21;
+  final int nFactorial = 17711;
+  final beforeRss = ProcessInfo.currentRss;
+
+  int maxRss = beforeRss;
+  final rssTimer = Timer.periodic(const Duration(milliseconds: 10), (_) {
+    maxRss = max(ProcessInfo.currentRss, maxRss);
+  });
+
+  final watch = Stopwatch();
+  watch.start();
+
+  // For the benefit of enable-isolate-groups configuration, warm up target
+  // isolate code by running couple iterations in the main isolate.
+  await Isolate.spawn(fibonacciRecursive, [rpWarmup.sendPort, nWarmup]);
+  Expect.equals(nWarmupFactorial, await rpWarmup.first);
+
+  final warmup = watch.elapsedMicroseconds;
+
+  await Isolate.spawn(fibonacciRecursive, [rpRun.sendPort, n]);
+  Expect.equals(nFactorial, await rpRun.first);
+
+  final done = watch.elapsedMicroseconds;
+
+  print('IsolateFibonacci_$n.Calculation(RunTimeRaw): ${done-warmup} us.');
+  print('IsolateFibonacci_$n.DeltaPeak(MemoryUse): ${maxRss-beforeRss}');
+  rssTimer.cancel();
+}

benchmarks/IsolateFibonacci/dart2/IsolateFibonacci.dart

@@ -0,0 +1,66 @@
+// 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 'dart:async';
+import 'dart:io';
+import 'dart:isolate';
+import 'dart:math';
+
+import 'package:expect/expect.dart';
+
+// Implements recursive summation via tail calls:
+//   fib(n) => n <= 1 ? 1
+//                    : fib(n-1) + fib(n-2);
+Future fibonacciRecursive(List args) async {
+  final SendPort port = args[0];
+  final n = args[1];
+  if (n <= 1) {
+    port.send(1);
+    return;
+  }
+  final left = ReceivePort();
+  final right = ReceivePort();
+  await Future.wait([
+    Isolate.spawn(fibonacciRecursive, [left.sendPort, n - 1]),
+    Isolate.spawn(fibonacciRecursive, [right.sendPort, n - 2]),
+  ]);
+  final results = await Future.wait([left.first, right.first]);
+  port.send(results[0] + results[1]);
+}
+
+Future<void> main() async {
+  final rpWarmup = ReceivePort();
+  final rpRun = ReceivePort();
+  final int nWarmup = 17; // enough runs to trigger optimized compilation
+  final int nWarmupFactorial = 2584;
+  // With --enable-isolate-groups runs for about 8 seconds.
+  // Should not be run witout --enable-isolate-groups as it would be too slow.
+  final int n = 21;
+  final int nFactorial = 17711;
+  final beforeRss = ProcessInfo.currentRss;
+
+  int maxRss = beforeRss;
+  final rssTimer = Timer.periodic(const Duration(milliseconds: 10), (_) {
+    maxRss = max(ProcessInfo.currentRss, maxRss);
+  });
+
+  final watch = Stopwatch();
+  watch.start();
+
+  // For the benefit of enable-isolate-groups configuration, warm up target
+  // isolate code by running couple iterations in the main isolate.
+  await Isolate.spawn(fibonacciRecursive, [rpWarmup.sendPort, nWarmup]);
+  Expect.equals(nWarmupFactorial, await rpWarmup.first);
+
+  final warmup = watch.elapsedMicroseconds;
+
+  await Isolate.spawn(fibonacciRecursive, [rpRun.sendPort, n]);
+  Expect.equals(nFactorial, await rpRun.first);
+
+  final done = watch.elapsedMicroseconds;
+
+  print('IsolateFibonacci_$n.Calculation(RunTimeRaw): ${done-warmup} us.');
+  print('IsolateFibonacci_$n.DeltaPeak(MemoryUse): ${maxRss-beforeRss}');
+  rssTimer.cancel();
+}

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/analysis/feature_set_provider.dart

@@ -12,10 +12,6 @@ import 'package:analyzer/src/util/uri.dart';
 import 'package:pub_semver/pub_semver.dart';
 
 class FeatureSetProvider {
-  /// This flag will be turned to `true` and inlined when we un-fork SDK,
-  /// so that the only SDK is the Null Safe SDK.
-  static const isNullSafetySdk = true;
-
   final Version _sdkLanguageVersion;
   final AllowedExperiments _allowedExperiments;
   final ResourceProvider _resourceProvider;

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;