Version 2.13.0-42.0.dev

Merge commit '4d5f027ccb2d998771677067a621bdd582ddfaf6' into 'dev'

Author: Dart CI

pkg/analysis_server/test/src/domains/completion/get_suggestion_details_test.dart

@@ -111,6 +111,104 @@ main() {} // ref
     _assertTestFileChange(result.change, r'''
 import 'dart:math';
 
+main() {} // ref
+''');
+  }
+
+  Future<void> test_newImport_afterLibraryBeforeFirstImportsAnnotation() async {
+    // Annotations are only treated as being for the file if they are on the first
+    // directive of the file.
+    addTestFile(r'''
+library foo;
+
+@myAnnotation
+import 'package:zzz';
+
+main() {} // ref
+''');
+
+    var mathSet = await waitForSetWithUri('dart:math');
+    var result = await _getSuggestionDetails(
+      _buildRequest(
+        id: mathSet.id,
+        label: 'sin',
+        offset: testCode.indexOf('} // ref'),
+      ),
+    );
+
+    expect(result.completion, 'sin');
+    _assertTestFileChange(result.change, r'''
+library foo;
+
+import 'dart:math';
+
+@myAnnotation
+import 'package:zzz';
+
+main() {} // ref
+''');
+  }
+
+  Future<void> test_newImport_betweenAnnotationAndFirstImport() async {
+    // Annotations attached to the first import in a file are considered
+    // to be for the file, so if an import is inserted in the top position, it
+    // should go after the annotation.
+    addTestFile(r'''
+@myAnnotation
+
+import 'package:zzz';
+
+main() {} // ref
+''');
+
+    var mathSet = await waitForSetWithUri('dart:math');
+    var result = await _getSuggestionDetails(
+      _buildRequest(
+        id: mathSet.id,
+        label: 'sin',
+        offset: testCode.indexOf('} // ref'),
+      ),
+    );
+
+    expect(result.completion, 'sin');
+    _assertTestFileChange(result.change, r'''
+@myAnnotation
+
+import 'dart:math';
+
+import 'package:zzz';
+
+main() {} // ref
+''');
+  }
+
+  Future<void> test_newImport_notBetweenAnnotationAndNonFirstImport() async {
+    // Annotations on non-first directives should not be kept above the newly
+    // imported imports (opposite of test_newImport_betweenAnnotationAndFirstImport).
+    addTestFile(r'''
+import 'dart:async';
+@myAnnotation
+import 'package:zzz';
+
+main() {} // ref
+''');
+
+    var mathSet = await waitForSetWithUri('dart:math');
+    var result = await _getSuggestionDetails(
+      _buildRequest(
+        id: mathSet.id,
+        label: 'sin',
+        offset: testCode.indexOf('} // ref'),
+      ),
+    );
+
+    expect(result.completion, 'sin');
+    _assertTestFileChange(result.change, r'''
+import 'dart:async';
+import 'dart:math';
+@myAnnotation
+import 'package:zzz';
+
 main() {} // ref
 ''');
   }

pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart

@@ -1515,7 +1515,14 @@ class DartFileEditBuilderImpl extends FileEditBuilderImpl
               writeImport(builder, import);
             });
           } else {
-            var offset = next.offset;
+            // Annotations attached to the first directive should remain above
+            // the newly inserted import, as they are treated as being for the
+            // file.
+            var isFirst =
+                next == (next.parent as CompilationUnit).directives.first;
+            var offset = isFirst && next is AnnotatedNode
+                ? next.firstTokenAfterCommentAndMetadata.offset
+                : next.offset;
             addInsertion(offset, (EditBuilder builder) {
               writeImport(builder, import);
               builder.writeln();

runtime/vm/object.cc

@@ -3172,7 +3172,6 @@ intptr_t Class::ComputeNumTypeArguments() const {
   // modified by finalization, only shifted to higher indices in the vector.
   // The super type may not even be resolved yet. This is not necessary, since
   // we only check for matching type parameters, which are resolved by default.
-  const auto& type_params = TypeArguments::Handle(zone, type_parameters());
   // Determine the maximum overlap of a prefix of the vector consisting of the
   // type parameters of this class with a suffix of the vector consisting of the
   // type arguments of the super type of this class.
@@ -3181,20 +3180,26 @@ intptr_t Class::ComputeNumTypeArguments() const {
   // Attempt to overlap the whole vector of type parameters; reduce the size
   // of the vector (keeping the first type parameter) until it fits or until
   // its size is zero.
-  auto& type_param = TypeParameter::Handle(zone);
   auto& sup_type_arg = AbstractType::Handle(zone);
   for (intptr_t num_overlapping_type_args =
            (num_type_params < sup_type_args_length) ? num_type_params
                                                     : sup_type_args_length;
        num_overlapping_type_args > 0; num_overlapping_type_args--) {
     intptr_t i = 0;
     for (; i < num_overlapping_type_args; i++) {
-      type_param ^= type_params.TypeAt(i);
-      ASSERT(!type_param.IsNull());
       sup_type_arg = sup_type_args.TypeAt(sup_type_args_length -
                                           num_overlapping_type_args + i);
       ASSERT(!sup_type_arg.IsNull());
-      if (!type_param.Equals(sup_type_arg)) break;
+      if (!sup_type_arg.IsTypeParameter()) break;
+      // The only type parameters appearing in the type arguments of the super
+      // type are those declared by this class. Their finalized indices depend
+      // on the number of type arguments being computed here. Therefore, they
+      // cannot possibly be finalized yet.
+      ASSERT(!TypeParameter::Cast(sup_type_arg).IsFinalized());
+      if (TypeParameter::Cast(sup_type_arg).index() != i ||
+          TypeParameter::Cast(sup_type_arg).IsNullable()) {
+        break;
+      }
     }
     if (i == num_overlapping_type_args) {
       // Overlap found.
@@ -21033,12 +21038,12 @@ bool TypeParameter::IsEquivalent(const Instance& other,
     return false;
   }
   const TypeParameter& other_type_param = TypeParameter::Cast(other);
+  ASSERT(IsFinalized() && other_type_param.IsFinalized());
   // Compare index, name, bound, default argument, and flags.
   if (IsFunctionTypeParameter()) {
     if (!other_type_param.IsFunctionTypeParameter()) {
       return false;
     }
-    ASSERT(IsFinalized() && other_type_param.IsFinalized());
     if (kind == TypeEquality::kInSubtypeTest) {
       // To be equivalent, the function type parameters should be declared
       // at the same position in the generic function. Their index therefore
@@ -21105,7 +21110,6 @@ bool TypeParameter::IsEquivalent(const Instance& other,
         return false;
       }
     } else {
-      ASSERT(IsFinalized() && other_type_param.IsFinalized());
       if (index() != other_type_param.index()) {
         return false;
       }

tests/language/regress/regress179942377_test.dart

@@ -0,0 +1,19 @@
+// 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.
+
+// Regression test for issue 179942377.
+
+import 'package:expect/expect.dart';
+
+class A<T> {
+  bool test() {
+    return null is T;
+  }
+}
+
+class B<T> extends A<T?> {}
+
+void main() {
+  Expect.isTrue(B<int>().test());
+}

tools/VERSION

@@ -27,5 +27,5 @@ CHANNEL dev
 MAJOR 2
 MINOR 13
 PATCH 0
-PRERELEASE 41
+PRERELEASE 42
 PRERELEASE_PATCH 0