Analyzer: forward const constructors to mixin apps as const

Fixes #41072

Relevant text from spec:

> If $S_q$ is a generative const constructor, and $MC$ does
> not declare any instance variables, $C_q$ is also a const
> constructor.

Relevant language tests:

  language_2/mixin_constructor_forwarding/const_constructor*

Change-Id: I8ad9e9dd3907b5dd29aa8f10aab6ec604a1aaa4b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/150682
Commit-Queue: Samuel Rawlins <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>

Author: srawlins

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

@@ -1049,6 +1049,9 @@ class ClassElementImpl extends AbstractClassElementImpl
     var substitution =
         Substitution.fromPairs(superClassParameters, argumentTypes);
 
+    bool typeHasInstanceVariables(InterfaceType type) =>
+        type.element.fields.any((e) => !e.isSynthetic);
+
     // Now create an implicit constructor for every constructor found above,
     // substituting type parameters as appropriate.
     return constructorsToForward
@@ -1057,6 +1060,9 @@ class ClassElementImpl extends AbstractClassElementImpl
           ConstructorElementImpl(superclassConstructor.name, -1);
       implicitConstructor.isSynthetic = true;
       implicitConstructor.redirectedConstructor = superclassConstructor;
+      var hasMixinWithInstanceVariables = mixins.any(typeHasInstanceVariables);
+      implicitConstructor.isConst =
+          superclassConstructor.isConst && !hasMixinWithInstanceVariables;
       List<ParameterElement> superParameters = superclassConstructor.parameters;
       int count = superParameters.length;
       if (count > 0) {

pkg/analyzer/test/generated/compile_time_error_code.dart

@@ -618,6 +618,58 @@ main() {
     ]);
   }
 
+  test_constWithNonConst_mixinApplication_constSuperConstructor() async {
+    await assertNoErrorsInCode(r'''
+mixin M {}
+class A {
+  const A();
+}
+class B = A with M;
+const b = const B();
+''');
+  }
+
+  test_constWithNonConst_mixinApplication_constSuperConstructor_field() async {
+    await assertErrorsInCode(r'''
+mixin M {
+  int i = 0;
+}
+class A {
+  const A();
+}
+class B = A with M;
+var b = const B();
+''', [
+      error(CompileTimeErrorCode.CONST_WITH_NON_CONST, 78, 5),
+    ]);
+  }
+
+  test_constWithNonConst_mixinApplication_constSuperConstructor_getter() async {
+    await assertNoErrorsInCode(r'''
+mixin M {
+  int get i => 0;
+}
+class A {
+  const A();
+}
+class B = A with M;
+var b = const B();
+''');
+  }
+
+  test_constWithNonConst_mixinApplication_constSuperConstructor_setter() async {
+    await assertNoErrorsInCode(r'''
+mixin M {
+  set(int i) {}
+}
+class A {
+  const A();
+}
+class B = A with M;
+var b = const B();
+''');
+  }
+
   test_constWithNonConstantArgument_annotation() async {
     await assertErrorsInCode(r'''
 class A {

pkg/analyzer/test/src/dart/resolution/class_alias_test.dart

@@ -2,6 +2,7 @@
 // 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/src/error/codes.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../../generated/elements_types_mixin.dart';
@@ -90,7 +91,6 @@ class X = Object with A, Function, B;
     );
   }
 
-  @failingTest
   test_implicitConstructors_const() async {
     await assertNoErrorsInCode(r'''
 class A {
@@ -103,7 +103,58 @@ class C = A with M;
 
 const x = const C();
 ''');
-    // TODO(scheglov) add also negative test with fields
+  }
+
+  test_implicitConstructors_const_field() async {
+    await assertErrorsInCode(r'''
+class A {
+  const A();
+}
+
+class M {
+  int i = 0;
+}
+
+class C = A with M;
+
+const x = const C();
+''', [
+      error(CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE, 83,
+          5),
+      error(CompileTimeErrorCode.CONST_WITH_NON_CONST, 83, 5),
+    ]);
+  }
+
+  test_implicitConstructors_const_getter() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  const A();
+}
+
+class M {
+  int get i => 0;
+}
+
+class C = A with M;
+
+const x = const C();
+''');
+  }
+
+  test_implicitConstructors_const_setter() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  const A();
+}
+
+class M {
+  set(int i) {}
+}
+
+class C = A with M;
+
+const x = const C();
+''');
   }
 
   test_implicitConstructors_dependencies() async {

pkg/analyzer/test/src/summary/resynthesize_common.dart

@@ -280,6 +280,30 @@ class E {
 ''');
   }
 
+  test_class_alias_with_const_constructors() async {
+    addLibrarySource('/a.dart', '''
+class Base {
+  const Base._priv();
+  const Base();
+  const Base.named();
+}
+''');
+    var library = await checkLibrary('''
+import "a.dart";
+class M {}
+class MixinApp = Base with M;
+''');
+    checkElementText(library, r'''
+import 'a.dart';
+class M {
+}
+class alias MixinApp extends Base with M {
+  synthetic const MixinApp() = Base;
+  synthetic const MixinApp.named() = Base.named;
+}
+''');
+  }
+
   test_class_alias_with_forwarding_constructors() async {
     addLibrarySource('/a.dart', '''
 class Base {
@@ -1854,33 +1878,33 @@ class A/*codeOffset=0, codeLength=10*/ {
 class B/*codeOffset=12, codeLength=10*/ {
 }
 class alias Raw/*codeOffset=28, codeLength=29*/ extends Object with A, B {
-  synthetic Raw() = Object;
+  synthetic const Raw() = Object;
 }
 /// Comment 1.
 /// Comment 2.
 class alias HasDocComment/*codeOffset=59, codeLength=69*/ extends Object with A, B {
-  synthetic HasDocComment() = Object;
+  synthetic const HasDocComment() = Object;
 }
 @Object()
 class alias HasAnnotation/*codeOffset=130, codeLength=49*/ extends Object with A, B {
-  synthetic HasAnnotation() = Object;
+  synthetic const HasAnnotation() = Object;
 }
 /// Comment 1.
 /// Comment 2.
 @Object()
 class alias AnnotationThenComment/*codeOffset=181, codeLength=87*/ extends Object with A, B {
-  synthetic AnnotationThenComment() = Object;
+  synthetic const AnnotationThenComment() = Object;
 }
 /// Comment 1.
 /// Comment 2.
 @Object()
 class alias CommentThenAnnotation/*codeOffset=270, codeLength=87*/ extends Object with A, B {
-  synthetic CommentThenAnnotation() = Object;
+  synthetic const CommentThenAnnotation() = Object;
 }
 /// Comment 2.
 @Object()
 class alias CommentAroundAnnotation/*codeOffset=374, codeLength=74*/ extends Object with A, B {
-  synthetic CommentAroundAnnotation() = Object;
+  synthetic const CommentAroundAnnotation() = Object;
 }
 ''',
         withCodeRanges: true,
@@ -5558,7 +5582,7 @@ class C extends Object with M {
   dynamic foo() {}
 }
 class alias D extends Object with M {
-  synthetic D() = Object;
+  synthetic const D() = Object;
 }
 ''');
   }