Version 2.19.0-414.0.dev

Merge ac1ad9f into dev

Author: Dart CI

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer.dart

@@ -484,49 +484,6 @@ mixin TypeAnalyzer<
     _analyzeIfCommon(node, ifTrue, ifFalse);
   }
 
-  /// Analyzes a variable declaration statement of the form
-  /// `pattern = initializer;`.
-  ///
-  /// [node] should be the AST node for the entire declaration, [pattern] for
-  /// the pattern, and [initializer] for the initializer.  [isFinal] and
-  /// [isLate] indicate whether this is a final declaration and/or a late
-  /// declaration, respectively.
-  ///
-  /// Note that the only kind of pattern allowed in a late declaration is a
-  /// variable pattern; [TypeAnalyzerErrors.patternDoesNotAllowLate] will be
-  /// reported if any other kind of pattern is used.
-  ///
-  /// Stack effect: pushes (Expression, Pattern).
-  void analyzeInitializedVariableDeclaration(
-      Node node, Pattern pattern, Expression initializer,
-      {required bool isFinal, required bool isLate}) {
-    // Stack: ()
-    if (isLate && !isVariablePattern(pattern)) {
-      errors?.patternDoesNotAllowLate(pattern);
-    }
-    if (isLate) {
-      flow?.lateInitializer_begin(node);
-    }
-    Type initializerType =
-        analyzeExpression(initializer, dispatchPatternSchema(pattern));
-    // Stack: (Expression)
-    if (isLate) {
-      flow?.lateInitializer_end();
-    }
-    dispatchPattern(
-      initializerType,
-      new MatchContext<Node, Expression, Pattern, Type, Variable>(
-        isFinal: isFinal,
-        isLate: isLate,
-        initializer: initializer,
-        irrefutableContext: node,
-        topPattern: pattern,
-      ),
-      pattern,
-    );
-    // Stack: (Expression, Pattern)
-  }
-
   /// Analyzes an integer literal, given the type context [context].
   ///
   /// Stack effect: none.
@@ -740,16 +697,23 @@ mixin TypeAnalyzer<
     Type matchedType,
     MatchContext<Node, Expression, Pattern, Type, Variable> context,
     Pattern node, {
-    required Type? requiredType,
     required List<RecordPatternField<Node, Pattern>> fields,
   }) {
     _reportDuplicateRecordPatternFields(fields);
 
-    requiredType ??= downwardInferObjectPatternRequiredType(
+    Type requiredType = downwardInferObjectPatternRequiredType(
       matchedType: matchedType,
       pattern: node,
     );
 
+    // If the required type is `dynamic` or `Never`, then every getter is
+    // treated as having the same type.
+    Type? overridePropertyGetType;
+    if (typeOperations.isDynamic(requiredType) ||
+        typeOperations.isNever(requiredType)) {
+      overridePropertyGetType = requiredType;
+    }
+
     Node? irrefutableContext = context.irrefutableContext;
     if (irrefutableContext != null &&
         !typeOperations.isAssignableTo(matchedType, requiredType)) {
@@ -763,10 +727,11 @@ mixin TypeAnalyzer<
 
     // Stack: ()
     for (RecordPatternField<Node, Pattern> field in fields) {
-      Type propertyType = resolveObjectPatternPropertyGet(
-        receiverType: requiredType,
-        field: field,
-      );
+      Type propertyType = overridePropertyGetType ??
+          resolveObjectPatternPropertyGet(
+            receiverType: requiredType,
+            field: field,
+          );
       dispatchPattern(propertyType, context, field.pattern);
     }
     // Stack: (n * Pattern) where n = fields.length
@@ -782,6 +747,49 @@ mixin TypeAnalyzer<
     return type;
   }
 
+  /// Analyzes a patternVariableDeclaration statement of the form
+  /// `var pattern = initializer;` or `final pattern = initializer;.
+  ///
+  /// [node] should be the AST node for the entire declaration, [pattern] for
+  /// the pattern, and [initializer] for the initializer.  [isFinal] and
+  /// [isLate] indicate whether this is a final declaration and/or a late
+  /// declaration, respectively.
+  ///
+  /// Note that the only kind of pattern allowed in a late declaration is a
+  /// variable pattern; [TypeAnalyzerErrors.patternDoesNotAllowLate] will be
+  /// reported if any other kind of pattern is used.
+  ///
+  /// Stack effect: pushes (Expression, Pattern).
+  void analyzePatternVariableDeclarationStatement(
+      Node node, Pattern pattern, Expression initializer,
+      {required bool isFinal, required bool isLate}) {
+    // Stack: ()
+    if (isLate && !isVariablePattern(pattern)) {
+      errors?.patternDoesNotAllowLate(pattern);
+    }
+    if (isLate) {
+      flow?.lateInitializer_begin(node);
+    }
+    Type initializerType =
+        analyzeExpression(initializer, dispatchPatternSchema(pattern));
+    // Stack: (Expression)
+    if (isLate) {
+      flow?.lateInitializer_end();
+    }
+    dispatchPattern(
+      initializerType,
+      new MatchContext<Node, Expression, Pattern, Type, Variable>(
+        isFinal: isFinal,
+        isLate: isLate,
+        initializer: initializer,
+        irrefutableContext: node,
+        topPattern: pattern,
+      ),
+      pattern,
+    );
+    // Stack: (Expression, Pattern)
+  }
+
   /// Analyzes a record pattern.  [node] is the pattern itself, and [fields]
   /// is the list of subpatterns.
   ///

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -265,11 +265,15 @@ Statement match(Pattern pattern, Expression initializer,
         isLate: isLate, isFinal: isFinal, location: computeLocation());
 
 Pattern objectPattern({
-  required ObjectPatternRequiredType requiredType,
+  required String requiredType,
   required List<RecordPatternField> fields,
 }) {
+  var parsedType = Type(requiredType);
+  if (parsedType is! PrimaryType) {
+    fail('Expected a primary type, got $parsedType');
+  }
   return _ObjectPattern(
-    requiredType: requiredType,
+    requiredType: parsedType,
     fields: fields,
     location: computeLocation(),
   );
@@ -754,6 +758,7 @@ class MiniAstOperations
     'int? <: Object': false,
     'int? <: Object?': true,
     'List<int> <: Object': true,
+    'Never <: Object': true,
     'Never <: Object?': true,
     'Null <: double?': true,
     'Null <: int': false,
@@ -881,7 +886,11 @@ class MiniAstOperations
   };
 
   static final Map<String, Type> _coreDownwardInferenceResults = {
+    'dynamic <: int': Type('dynamic'),
+    'int <: num': Type('int'),
     'List <: Iterable<int>': Type('List<int>'),
+    'Never <: int': Type('Never'),
+    'num <: int': Type('num'),
   };
 
   static final Map<String, Type> _coreNormalizeResults = {
@@ -1008,7 +1017,7 @@ class MiniAstOperations
 
   @override
   bool isDynamic(Type type) =>
-      type is NonFunctionType && type.name == 'dynamic' && type.args.isEmpty;
+      type is PrimaryType && type.name == 'dynamic' && type.args.isEmpty;
 
   @override
   bool isNever(Type type) {
@@ -1048,7 +1057,7 @@ class MiniAstOperations
 
   @override
   Type? matchIterableType(Type type) {
-    if (type is NonFunctionType &&
+    if (type is PrimaryType &&
         type.name == 'Iterable' &&
         type.args.length == 1) {
       return type.args[0];
@@ -1058,9 +1067,7 @@ class MiniAstOperations
 
   @override
   Type? matchListType(Type type) {
-    if (type is NonFunctionType &&
-        type.name == 'List' &&
-        type.args.length == 1) {
+    if (type is PrimaryType && type.name == 'List' && type.args.length == 1) {
       return type.args[0];
     }
     return null;
@@ -1157,27 +1164,6 @@ class Node {
   String toString() => 'Node#$id';
 }
 
-/// Either the type, or the name of a type constructor.
-class ObjectPatternRequiredType {
-  final Type? type;
-  final String? name;
-
-  ObjectPatternRequiredType.name(this.name) : type = null;
-
-  ObjectPatternRequiredType.type(String type)
-      : type = Type(type),
-        name = null;
-
-  @override
-  String toString() {
-    if (type != null) {
-      return '(type: $type)';
-    } else {
-      return '(name: $name)';
-    }
-  }
-}
-
 abstract class Pattern extends Node
     with PossiblyGuardedPattern
     implements ListPatternElement {
@@ -2018,7 +2004,7 @@ class _Declare extends Statement {
       irName = 'declare';
       argKinds = [Kind.pattern];
     } else {
-      h.typeAnalyzer.analyzeInitializedVariableDeclaration(
+      h.typeAnalyzer.analyzePatternVariableDeclarationStatement(
           this, pattern, initializer,
           isFinal: isFinal, isLate: isLate);
       irName = 'match';
@@ -3241,11 +3227,12 @@ class _MiniAstTypeAnalyzer
     required Type matchedType,
     required covariant _ObjectPattern pattern,
   }) {
-    var name = pattern.requiredType.name;
-    if (name == null) {
-      fail('Expected type constructor name at ${pattern.location}');
+    var requiredType = pattern.requiredType;
+    if (requiredType.args.isNotEmpty) {
+      return requiredType;
+    } else {
+      return typeOperations.downwardInfer(requiredType.name, matchedType);
     }
-    return typeOperations.downwardInfer(name, matchedType);
   }
 
   void finish() {
@@ -3483,8 +3470,7 @@ class _MiniAstTypeAnalyzer
   Type leastUpperBound(Type t1, Type t2) => _harness._operations._lub(t1, t2);
 
   @override
-  Type listType(Type elementType) =>
-      NonFunctionType('List', args: [elementType]);
+  Type listType(Type elementType) => PrimaryType('List', args: [elementType]);
 
   _PropertyElement lookupInterfaceMember(
       Node node, Type receiverType, String memberName) {
@@ -3678,7 +3664,7 @@ class _NullLiteral extends Expression {
 }
 
 class _ObjectPattern extends Pattern {
-  final ObjectPatternRequiredType requiredType;
+  final PrimaryType requiredType;
   final List<RecordPatternField> fields;
 
   _ObjectPattern({
@@ -3689,7 +3675,7 @@ class _ObjectPattern extends Pattern {
 
   @override
   Type computeSchema(Harness h) {
-    return h.typeAnalyzer.analyzeObjectPatternSchema(requiredType.type!);
+    return h.typeAnalyzer.analyzeObjectPatternSchema(requiredType);
   }
 
   @override
@@ -3708,9 +3694,8 @@ class _ObjectPattern extends Pattern {
     Type matchedType,
     SharedMatchContext context,
   ) {
-    var requiredType = h.typeAnalyzer.analyzeObjectPattern(
-        matchedType, context, this,
-        requiredType: this.requiredType.type, fields: fields);
+    var requiredType = h.typeAnalyzer
+        .analyzeObjectPattern(matchedType, context, this, fields: fields);
     h.irBuilder.atom(matchedType.type, Kind.type, location: location);
     h.irBuilder.atom(requiredType.type, Kind.type, location: location);
     h.irBuilder.apply(

pkg/_fe_analyzer_shared/test/mini_types.dart

@@ -54,25 +54,35 @@ class NamedType {
   String toString() => '$type $name';
 }
 
-/// Representation of a "simple" type suitable for unit testing of code in the
-/// `_fe_analyzer_shared` package.  A "simple" type is either an interface type
+/// Exception thrown if a type fails to parse properly.
+class ParseError extends Error {
+  final String message;
+
+  ParseError(this.message);
+
+  @override
+  String toString() => message;
+}
+
+/// Representation of a primary type suitable for unit testing of code in the
+/// `_fe_analyzer_shared` package.  A primary type is either an interface type
 /// with zero or more type parameters (e.g. `double`, or `Map<int, String>`), a
 /// reference to a type parameter, or one of the special types whose name is a
 /// single word (e.g. `dynamic`).
-class NonFunctionType extends Type {
+class PrimaryType extends Type {
   /// The name of the type.
   final String name;
 
   /// The type arguments, or `const []` if there are no type arguments.
   final List<Type> args;
 
-  NonFunctionType(this.name, {this.args = const []}) : super._();
+  PrimaryType(this.name, {this.args = const []}) : super._();
 
   @override
   Type? recursivelyDemote({required bool covariant}) {
     List<Type>? newArgs = args.recursivelyDemote(covariant: covariant);
     if (newArgs == null) return null;
-    return NonFunctionType(name, args: newArgs);
+    return PrimaryType(name, args: newArgs);
   }
 
   @override
@@ -85,16 +95,6 @@ class NonFunctionType extends Type {
   }
 }
 
-/// Exception thrown if a type fails to parse properly.
-class ParseError extends Error {
-  final String message;
-
-  ParseError(this.message);
-
-  @override
-  String toString() => message;
-}
-
 /// Representation of a promoted type parameter type suitable for unit testing
 /// of code in the `_fe_analyzer_shared` package.  A promoted type parameter is
 /// often written using the syntax `a&b`, where `a` is the type parameter and
@@ -109,7 +109,7 @@ class PromotedTypeVariableType extends Type {
 
   @override
   Type? recursivelyDemote({required bool covariant}) =>
-      covariant ? innerType : new NonFunctionType('Never');
+      covariant ? innerType : new PrimaryType('Never');
 
   @override
   String _toString({required bool allowSuffixes}) {
@@ -493,7 +493,7 @@ class _TypeParser {
     } else {
       typeArgs = const [];
     }
-    return NonFunctionType(typeName, args: typeArgs);
+    return PrimaryType(typeName, args: typeArgs);
   }
 
   static Type parse(String typeStr) {