Version 2.18.0-245.0.dev

Merge commit '99919c69ba1f374a8d793bcfe43e2a1702a1b82b' into 'dev'

Author: Dart CI

pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart

@@ -247,9 +247,9 @@ abstract class Expression extends Node {
 }
 
 /// Test harness for creating flow analysis tests.  This class implements all
-/// the [TypeOperations] needed by flow analysis, as well as other methods
-/// needed for testing.
-class Harness extends TypeOperations<Var, Type> {
+/// the [Operations] needed by flow analysis, as well as other methods needed
+/// for testing.
+class Harness extends Operations<Var, Type> {
   static const Map<String, bool> _coreSubtypes = const {
     'bool <: int': false,
     'bool <: Object': true,
@@ -1486,7 +1486,7 @@ class _MiniAstTypeAnalyzer {
     var rightType = analyzeExpression(rhs);
     flow.ifNullExpression_end();
     return leastUpperBound(
-        flow.typeOperations.promoteToNonNull(leftType), rightType);
+        flow.operations.promoteToNonNull(leftType), rightType);
   }
 
   void analyzeIfStatement(Statement node, Expression condition,
@@ -1520,7 +1520,7 @@ class _MiniAstTypeAnalyzer {
   Type analyzeNonNullAssert(Expression node, Expression expression) {
     var type = analyzeExpression(expression);
     flow.nonNullAssert_end(expression);
-    return flow.typeOperations.promoteToNonNull(type);
+    return flow.operations.promoteToNonNull(type);
   }
 
   Type analyzeNullLiteral(Expression node) {

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -59,7 +59,7 @@ class FlowAnalysisDataForTesting {
 /// be extracted.
 class FlowAnalysisHelper {
   /// The reused instance for creating new [FlowAnalysis] instances.
-  final TypeSystemTypeOperations _typeOperations;
+  final TypeSystemOperations _typeOperations;
 
   /// Precomputed sets of potentially assigned variables.
   AssignedVariables<AstNode, PromotableElement>? assignedVariables;
@@ -82,7 +82,7 @@ class FlowAnalysisHelper {
 
   FlowAnalysisHelper(TypeSystemImpl typeSystem, bool retainDataForTesting,
       FeatureSet featureSet)
-      : this._(TypeSystemTypeOperations(typeSystem),
+      : this._(TypeSystemOperations(typeSystem),
             retainDataForTesting ? FlowAnalysisDataForTesting() : null,
             isNonNullableByDefault: featureSet.isEnabled(Feature.non_nullable),
             respectImplicitlyTypedVarInitializers:
@@ -375,11 +375,10 @@ class FlowAnalysisHelperForMigration extends FlowAnalysisHelper {
   }
 }
 
-class TypeSystemTypeOperations
-    extends TypeOperations<PromotableElement, DartType> {
+class TypeSystemOperations extends Operations<PromotableElement, DartType> {
   final TypeSystemImpl typeSystem;
 
-  TypeSystemTypeOperations(this.typeSystem);
+  TypeSystemOperations(this.typeSystem);
 
   @override
   TypeClassification classifyType(DartType type) {

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

@@ -369,15 +369,20 @@ Future writeAppendedMachOExecutable(
     // Thus, to sign the binary, the developer must force signature overwriting.
     final signingProcess = await Process.run('codesign', args);
     if (signingProcess.exitCode != 0) {
-      print('Failed to replace the dartaotruntime signature, ');
-      print('subcommand terminated with exit code ${signingProcess.exitCode}.');
+      stderr
+        ..write('Failed to replace the dartaotruntime signature, ')
+        ..write('subcommand terminated with exit code ')
+        ..write(signingProcess.exitCode)
+        ..writeln('.');
       if (signingProcess.stdout.isNotEmpty) {
-        print('Subcommand stdout:');
-        print(signingProcess.stdout);
+        stderr
+          ..writeln('Subcommand stdout:')
+          ..writeln(signingProcess.stdout);
       }
       if (signingProcess.stderr.isNotEmpty) {
-        print('Subcommand stderr:');
-        print(signingProcess.stderr);
+        stderr
+          ..writeln('Subcommand stderr:')
+          ..writeln(signingProcess.stderr);
       }
       throw 'Could not sign the new executable';
     }

pkg/dart2native/lib/dart2native_macho.dart

@@ -260,10 +260,10 @@ class FlowAnalysisResult {
 }
 
 /// CFE-specific implementation of [TypeOperations].
-class TypeOperationsCfe extends TypeOperations<VariableDeclaration, DartType> {
+class OperationsCfe extends Operations<VariableDeclaration, DartType> {
   final TypeEnvironment typeEnvironment;
 
-  TypeOperationsCfe(this.typeEnvironment);
+  OperationsCfe(this.typeEnvironment);
 
   @override
   TypeClassification classifyType(DartType? type) {

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

@@ -228,16 +228,14 @@ class TypeInferrerImpl implements TypeInferrer {
 
   @override
   late final FlowAnalysis<TreeNode, Statement, Expression, VariableDeclaration,
-          DartType> flowAnalysis =
-      libraryBuilder.isNonNullableByDefault
-          ? new FlowAnalysis(
-              new TypeOperationsCfe(engine.typeSchemaEnvironment),
-              assignedVariables,
-              respectImplicitlyTypedVarInitializers:
-                  libraryBuilder.libraryFeatures.constructorTearoffs.isEnabled)
-          : new FlowAnalysis.legacy(
-              new TypeOperationsCfe(engine.typeSchemaEnvironment),
-              assignedVariables);
+      DartType> flowAnalysis = libraryBuilder
+          .isNonNullableByDefault
+      ? new FlowAnalysis(
+          new OperationsCfe(engine.typeSchemaEnvironment), assignedVariables,
+          respectImplicitlyTypedVarInitializers:
+              libraryBuilder.libraryFeatures.constructorTearoffs.isEnabled)
+      : new FlowAnalysis.legacy(
+          new OperationsCfe(engine.typeSchemaEnvironment), assignedVariables);
 
   @override
   final AssignedVariables<TreeNode, VariableDeclaration> assignedVariables;

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

@@ -11,9 +11,9 @@ import 'package:nnbd_migration/src/edge_origin.dart';
 import 'package:nnbd_migration/src/nullability_node.dart';
 import 'package:nnbd_migration/src/variables.dart';
 
-/// [TypeOperations] that works with [DecoratedType]s.
+/// [Operations] that works with [DecoratedType]s.
 class DecoratedTypeOperations
-    implements TypeOperations<PromotableElement, DecoratedType> {
+    implements Operations<PromotableElement, DecoratedType> {
   final TypeSystem _typeSystem;
   final Variables? _variableRepository;
   final NullabilityGraph _graph;

pkg/nnbd_migration/lib/src/decorated_type_operations.dart

@@ -0,0 +1,49 @@
+// Copyright (c) 2022, 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.
+
+// VMOptions=--use_slow_path --stress_write_barrier_elimination
+
+// Test that array allocation in noSuchMethod dispatcher is preserving the
+// length register correctly.
+
+import 'dart:async';
+
+import 'package:expect/expect.dart';
+
+final List<dynamic> list = <dynamic>[];
+
+final List<int> invocations = <int>[];
+
+abstract class B {
+  void someMethod(int v);
+}
+
+class A {
+  noSuchMethod(Invocation i) {
+    Expect.equals(#someMethod, i.memberName);
+    invocations.add(i.positionalArguments[0] as int);
+  }
+}
+
+class C implements B {
+  void someMethod(int v) {
+    invocations.add(v);
+  }
+}
+
+void main() {
+  for (var i = 0; i < 10; i++) {
+    list.add(A());
+    list.add(C());
+  }
+
+  for (var i = 0; i < list.length; i++) {
+    list[i].someMethod(i);
+  }
+
+  Expect.equals(list.length, invocations.length);
+  for (var i = 0; i < list.length; i++) {
+    Expect.equals(i, invocations[i]);
+  }
+}

runtime/tests/vm/dart/flutter_regress_106510_test.dart

@@ -0,0 +1,50 @@
+// Copyright (c) 2022, 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.
+// @dart=2.9
+
+// VMOptions=--use_slow_path --stress_write_barrier_elimination
+
+// Test that array allocation in noSuchMethod dispatcher is preserving the
+// length register correctly.
+
+import 'dart:async';
+
+import 'package:expect/expect.dart';
+
+final List<dynamic> list = <dynamic>[];
+
+final List<int> invocations = <int>[];
+
+abstract class B {
+  void someMethod(int v);
+}
+
+class A {
+  noSuchMethod(Invocation i) {
+    Expect.equals(#someMethod, i.memberName);
+    invocations.add(i.positionalArguments[0] as int);
+  }
+}
+
+class C implements B {
+  void someMethod(int v) {
+    invocations.add(v);
+  }
+}
+
+void main() {
+  for (var i = 0; i < 10; i++) {
+    list.add(A());
+    list.add(C());
+  }
+
+  for (var i = 0; i < list.length; i++) {
+    list[i].someMethod(i);
+  }
+
+  Expect.equals(list.length, invocations.length);
+  for (var i = 0; i < list.length; i++) {
+    Expect.equals(i, invocations[i]);
+  }
+}

runtime/tests/vm/dart_2/flutter_regress_106510_test.dart

@@ -46,7 +46,7 @@ void StubCodeCompiler::EnsureIsNewOrRemembered(Assembler* assembler,
   {
     LeafRuntimeScope rt(assembler,
                         /*frame_size=*/0,
-                        /*preserve_registers=*/false);
+                        /*preserve_registers=*/preserve_registers);
     // [R0] already contains first argument.
     __ mov(R1, Operand(THR));
     rt.Call(kEnsureRememberedAndMarkingDeferredRuntimeEntry, 2);

runtime/vm/compiler/stub_code_compiler_arm.cc

@@ -27,5 +27,5 @@ CHANNEL dev
 MAJOR 2
 MINOR 18
 PATCH 0
-PRERELEASE 244
+PRERELEASE 245
 PRERELEASE_PATCH 0