DeCo. Infer the type of declaring formal parameter and field from the default value.

Bug: #61701
Change-Id: Ibd2e468b409a2133b4ebea38da0f94ffdd7bef82
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/460200
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -2802,12 +2802,6 @@ class FieldElementImpl extends PropertyInducingElementImpl
     return super.setter;
   }
 
-  @override
-  set type(TypeImpl value) {
-    super.type = value;
-    declaringFormalParameter?.type = value;
-  }
-
   @override
   List<FieldFragmentImpl> get _fragments {
     return [

pkg/analyzer/lib/src/summary2/top_level_inference.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/dart/element/scope.dart';
 import 'package:analyzer/src/dart/analysis/analysis_options.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/extensions.dart';
@@ -153,9 +154,22 @@ class _InitializerInference {
   }
 
   void _addVariableNode(PropertyInducingElementImpl element) {
-    if (element.isSynthetic &&
-        !(element is FieldElementImpl && element.isSyntheticEnumField)) {
-      return;
+    if (element.isSynthetic) {
+      var shouldInfer = false;
+      if (element is FieldElementImpl) {
+        // For enums `values` is purely synthetic.
+        if (element.isEnumValues) {
+          shouldInfer = true;
+        }
+        // For declaring formal parameters the field is synthetic.
+        // But we want to infer the type from the default value.
+        if (element.declaringFormalParameter != null) {
+          shouldInfer = true;
+        }
+      }
+      if (!shouldInfer) {
+        return;
+      }
     }
 
     if (!element.hasImplicitType) return;
@@ -195,17 +209,33 @@ class _PropertyInducingElementTypeInference
 
   @override
   TypeImpl perform() {
-    PropertyInducingFragmentImpl? initializerFragment;
-    VariableDeclarationImpl? variableDeclaration;
+    LibraryFragmentImpl? initializerLibraryFragment;
+    Scope? scope;
+    ExpressionImpl Function()? getInitializer;
     for (var fragment in _element.fragments) {
-      var node = _linker.elementNodes[fragment] as VariableDeclarationImpl;
-      if (node.initializer != null) {
-        initializerFragment = fragment;
-        variableDeclaration = node;
+      var node = _linker.elementNodes[fragment];
+      switch (node) {
+        case VariableDeclarationImpl():
+          if (node.initializer != null) {
+            initializerLibraryFragment = fragment.libraryFragment;
+            scope = LinkingNodeContext.get(node).scope;
+            getInitializer = () => node.initializer!;
+          }
+        case DefaultFormalParameterImpl():
+          if (node.defaultValue != null) {
+            initializerLibraryFragment = fragment.libraryFragment;
+            scope = LinkingNodeContext.get(node).scope;
+            getInitializer = () => node.defaultValue!;
+          } else {
+            _status = _InferenceStatus.inferred;
+            return _element.library.typeSystem.objectQuestion;
+          }
       }
     }
 
-    if (initializerFragment == null || variableDeclaration == null) {
+    if (initializerLibraryFragment == null ||
+        scope == null ||
+        getInitializer == null) {
       _status = _InferenceStatus.inferred;
       return DynamicTypeImpl.instance;
     }
@@ -246,17 +276,15 @@ class _PropertyInducingElementTypeInference
     var enclosingInterfaceElement = enclosingElement
         .ifTypeOrNull<InterfaceElementImpl>();
 
-    var scope = LinkingNodeContext.get(variableDeclaration).scope;
-
     var analysisOptions = _libraryBuilder.kind.file.analysisOptions;
     var astResolver = AstResolver(
       _linker,
-      initializerFragment.libraryFragment,
+      initializerLibraryFragment,
       scope,
       analysisOptions,
       enclosingClassElement: enclosingInterfaceElement,
     );
-    astResolver.resolveExpression(() => variableDeclaration!.initializer!);
+    astResolver.resolveExpression(getInitializer);
 
     // Pop self from the stack.
     var self = _inferring.removeLast();
@@ -270,12 +298,19 @@ class _PropertyInducingElementTypeInference
       _status = _InferenceStatus.inferred;
     }
 
-    var initializerType = variableDeclaration.initializer!.typeOrThrow;
+    var initializerType = getInitializer().typeOrThrow;
     return _refineType(initializerType);
   }
 
   TypeImpl _refineType(TypeImpl type) {
     if (type.isDartCoreNull) {
+      // When `T` is `Null`, `p` has declared type `Object?`.
+      if (_element case FieldElementImpl field) {
+        if (field.declaringFormalParameter != null) {
+          return _element.library.typeSystem.objectQuestion;
+        }
+      }
+      // Logic for older language versions.
       return DynamicTypeImpl.instance;
     }
 

pkg/analyzer/lib/src/summary2/types_builder.dart

@@ -397,8 +397,22 @@ class TypesBuilder {
 
   void _simpleFormalParameter(SimpleFormalParameterImpl node) {
     var fragment = node.declaredFragment!;
-    if (fragment.previousFragment == null) {
-      fragment.element.type = node.type?.type ?? _dynamicType;
+    if (fragment.previousFragment != null) {
+      return;
+    }
+
+    var element = fragment.element;
+
+    var typeAnnotation = node.type;
+    if (typeAnnotation == null) {
+      // For a declaring formal parameter the type will be inferred from
+      // the field type via instance inference, or from the default value.
+      if (element is FieldFormalParameterElementImpl && element.isDeclaring) {
+        return;
+      }
+      element.type = _dynamicType;
+    } else {
+      element.type = typeAnnotation.typeOrThrow;
     }
   }