Version 2.19.0-367.0.dev

Merge 6539e20 into dev

Author: Dart CI

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

@@ -22,6 +22,34 @@ class CaseHeadOrDefaultInfo<Node extends Object, Expression extends Node> {
   CaseHeadOrDefaultInfo({required this.pattern, this.guard});
 }
 
+class NamedType<Type extends Object> {
+  final String name;
+  final Type type;
+
+  NamedType(this.name, this.type);
+}
+
+class RecordPatternField<Pattern extends Object> {
+  /// If not `null` then the field is named, otherwise it is positional.
+  final String? name;
+  final Pattern pattern;
+
+  RecordPatternField({
+    required this.name,
+    required this.pattern,
+  });
+}
+
+class RecordType<Type extends Object> {
+  final List<Type> positional;
+  final List<NamedType<Type>> named;
+
+  RecordType({
+    required this.positional,
+    required this.named,
+  });
+}
+
 /// Information about a relational operator.
 class RelationalOperatorResolution<Type extends Object> {
   /// Is `true` when the operator is `==` or `!=`.
@@ -533,6 +561,110 @@ mixin TypeAnalyzer<Node extends Object, Statement extends Node,
     }
   }
 
+  /// Analyzes a record pattern.  [node] is the pattern itself, and [fields]
+  /// is the list of subpatterns.
+  ///
+  /// See [dispatchPattern] for the meanings of [matchedType], [typeInfos], and
+  /// [context].
+  ///
+  /// Stack effect: pushes (n * Pattern) where n = fields.length.
+  Type analyzeRecordPattern(
+    Type matchedType,
+    Map<Variable, VariableTypeInfo<Node, Type>> typeInfos,
+    MatchContext<Node, Expression> context,
+    Node node, {
+    required List<RecordPatternField<Node>> fields,
+  }) {
+    void dispatchField(RecordPatternField<Node> field, Type matchedType) {
+      dispatchPattern(matchedType, typeInfos, context, field.pattern);
+    }
+
+    void dispatchFields(Type matchedType) {
+      for (int i = 0; i < fields.length; i++) {
+        dispatchField(fields[i], matchedType);
+      }
+    }
+
+    // Build the required type.
+    int requiredTypePositionalCount = 0;
+    List<NamedType<Type>> requiredTypeNamedTypes = [];
+    for (RecordPatternField<Node> field in fields) {
+      String? name = field.name;
+      if (name == null) {
+        requiredTypePositionalCount++;
+      } else {
+        requiredTypeNamedTypes.add(
+          new NamedType(name, objectQuestionType),
+        );
+      }
+    }
+    Type requiredType = recordType(
+      new RecordType(
+        positional: new List.filled(
+          requiredTypePositionalCount,
+          objectQuestionType,
+        ),
+        named: requiredTypeNamedTypes,
+      ),
+    );
+
+    // Stack: ()
+    RecordType<Type>? matchedRecordType = asRecordType(matchedType);
+    if (matchedRecordType != null) {
+      List<Type>? fieldTypes = _matchRecordTypeShape(fields, matchedRecordType);
+      if (fieldTypes != null) {
+        assert(fieldTypes.length == fields.length);
+        for (int i = 0; i < fields.length; i++) {
+          dispatchField(fields[i], fieldTypes[i]);
+        }
+      } else {
+        dispatchFields(objectQuestionType);
+      }
+    } else if (typeOperations.isDynamic(matchedType)) {
+      dispatchFields(dynamicType);
+    } else {
+      dispatchFields(objectQuestionType);
+    }
+    // Stack: (n * Pattern) where n = fields.length
+
+    Node? irrefutableContext = context.irrefutableContext;
+    if (irrefutableContext != null &&
+        !typeOperations.isAssignableTo(matchedType, requiredType)) {
+      errors?.patternTypeMismatchInIrrefutableContext(
+        pattern: node,
+        context: irrefutableContext,
+        matchedType: matchedType,
+        requiredType: requiredType,
+      );
+    }
+    return requiredType;
+  }
+
+  /// Computes the type schema for a record pattern.
+  ///
+  /// Stack effect: none.
+  Type analyzeRecordPatternSchema({
+    required List<RecordPatternField<Node>> fields,
+  }) {
+    List<Type> positional = [];
+    List<NamedType<Type>> named = [];
+    for (RecordPatternField<Node> field in fields) {
+      Type fieldType = dispatchPatternSchema(field.pattern);
+      String? name = field.name;
+      if (name != null) {
+        named.add(new NamedType(name, fieldType));
+      } else {
+        positional.add(fieldType);
+      }
+    }
+    return recordType(
+      new RecordType<Type>(
+        positional: positional,
+        named: named,
+      ),
+    );
+  }
+
   /// Analyzes a relational pattern.  [node] is the pattern itself, [operator]
   /// is the resolution of the used relational operator, and [operand] is a
   /// constant expression.
@@ -836,6 +968,9 @@ mixin TypeAnalyzer<Node extends Object, Statement extends Node,
   Type analyzeVariablePatternSchema(Type? declaredType) =>
       declaredType ?? unknownType;
 
+  /// If [type] is a record type, returns it.
+  RecordType<Type>? asRecordType(Type type);
+
   /// Calls the appropriate `analyze` method according to the form of
   /// [expression], and then adjusts the stack as needed to combine any
   /// sub-structures into a single expression.
@@ -1006,6 +1141,9 @@ mixin TypeAnalyzer<Node extends Object, Statement extends Node,
   /// Returns the type `List`, with type parameter [elementType].
   Type listType(Type elementType);
 
+  /// Builds the client specific record type.
+  Type recordType(RecordType<Type> type);
+
   /// Records that type inference has assigned a [type] to a [variable].  This
   /// is called once per variable, regardless of whether the variable's type is
   /// explicit or inferred.
@@ -1046,6 +1184,49 @@ mixin TypeAnalyzer<Node extends Object, Statement extends Node,
     }
   }
 
+  /// If the shape described by [fields] is the same as the shape of the
+  /// [matchedType], returns matched types for each field in [fields].
+  /// Otherwise returns `null`.
+  List<Type>? _matchRecordTypeShape(
+    List<RecordPatternField<Node>> fields,
+    RecordType<Type> matchedType,
+  ) {
+    Map<String, Type> matchedTypeNamed = {};
+    for (NamedType<Type> namedField in matchedType.named) {
+      matchedTypeNamed[namedField.name] = namedField.type;
+    }
+
+    List<Type> result = [];
+    int positionalIndex = 0;
+    int namedCount = 0;
+    for (RecordPatternField<Node> field in fields) {
+      Type? fieldType;
+      String? name = field.name;
+      if (name != null) {
+        fieldType = matchedTypeNamed[name];
+        if (fieldType == null) {
+          return null;
+        }
+        namedCount++;
+      } else {
+        if (positionalIndex >= matchedType.positional.length) {
+          return null;
+        }
+        fieldType = matchedType.positional[positionalIndex++];
+      }
+      result.add(fieldType);
+    }
+    if (positionalIndex != matchedType.positional.length) {
+      return null;
+    }
+    if (namedCount != matchedTypeNamed.length) {
+      return null;
+    }
+
+    assert(result.length == fields.length);
+    return result;
+  }
+
   /// Records in [typeInfos] that a [pattern] binds a [variable] with a given
   /// [staticType], and reports any errors caused by type inconsistency.
   /// [isImplicitlyTyped] indicates whether the variable is implicitly typed in

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -10,7 +10,10 @@ import 'package:_fe_analyzer_shared/src/flow_analysis/flow_analysis.dart'
     show EqualityInfo, FlowAnalysis, Operations;
 import 'package:_fe_analyzer_shared/src/type_inference/assigned_variables.dart';
 import 'package:_fe_analyzer_shared/src/type_inference/type_analysis_result.dart';
-import 'package:_fe_analyzer_shared/src/type_inference/type_analyzer.dart';
+import 'package:_fe_analyzer_shared/src/type_inference/type_analyzer.dart'
+    hide NamedType, RecordType;
+import 'package:_fe_analyzer_shared/src/type_inference/type_analyzer.dart'
+    as shared;
 import 'package:_fe_analyzer_shared/src/type_inference/type_operations.dart';
 import 'package:_fe_analyzer_shared/src/type_inference/variable_bindings.dart';
 import 'package:test/test.dart';
@@ -119,6 +122,11 @@ Statement do_(List<Statement> body, Expression condition) {
 Expression expr(String typeStr) =>
     new _PlaceholderExpression(new Type(typeStr), location: computeLocation());
 
+/// Creates a pseudo-expression having type [type] that otherwise has no
+/// effect on flow analysis.
+Expression expr2(Type type) =>
+    new _PlaceholderExpression(type, location: computeLocation());
+
 /// Creates a conventional `for` statement.  Optional boolean [forCollection]
 /// indicates that this `for` statement is actually a collection element, so
 /// `null` should be passed to [for_bodyBegin].
@@ -220,6 +228,9 @@ Statement match(Pattern pattern, Expression initializer,
 
 CaseHeads mergedCase(List<CaseHead> cases) => _CaseHeads(cases, const []);
 
+Pattern recordPattern(List<RecordPatternField<Pattern>> fields) =>
+    _RecordPattern(fields, location: computeLocation());
+
 Pattern relationalPattern(
         RelationalOperatorResolution<Type>? operator, Expression operand) =>
     _RelationalPattern(operator, operand, location: computeLocation());
@@ -2692,6 +2703,22 @@ class _MiniAstTypeAnalyzer
     flow.whileStatement_end();
   }
 
+  @override
+  shared.RecordType<Type>? asRecordType(Type type) {
+    if (type is RecordType) {
+      return shared.RecordType<Type>(
+        positional: type.positional,
+        named: type.named.map((namedType) {
+          return shared.NamedType(
+            namedType.name,
+            namedType.innerType,
+          );
+        }).toList(),
+      );
+    }
+    return null;
+  }
+
   @override
   ExpressionTypeAnalysisResult<Type> dispatchExpression(
           Expression expression, Type context) =>
@@ -2840,6 +2867,14 @@ class _MiniAstTypeAnalyzer
     return _harness.getMember(receiverType, memberName);
   }
 
+  @override
+  RecordType recordType(shared.RecordType<Type> type) {
+    return RecordType(
+      positional: type.positional,
+      named: type.named.map((e) => NamedType(e.name, e.type)).toList(),
+    );
+  }
+
   @override
   void setVariableType(Var variable, Type type) {
     variable.type = type;
@@ -3089,6 +3124,57 @@ class _PropertyElement {
   _PropertyElement(this._type);
 }
 
+class _RecordPattern extends Pattern {
+  final List<RecordPatternField<Pattern>> fields;
+
+  _RecordPattern(this.fields, {required super.location}) : super._();
+
+  Type computeSchema(Harness h) {
+    return h.typeAnalyzer.analyzeRecordPatternSchema(
+      fields: fields,
+    );
+  }
+
+  @override
+  void preVisit(
+    PreVisitor visitor,
+    VariableBinder<Node, Var, Type> variableBinder,
+  ) {
+    for (var field in fields) {
+      field.pattern.preVisit(visitor, variableBinder);
+    }
+  }
+
+  void visit(
+    Harness h,
+    Type matchedType,
+    Map<Var, VariableTypeInfo<Node, Type>> typeInfos,
+    MatchContext<Node, Expression> context,
+  ) {
+    var requiredType = h.typeAnalyzer.analyzeRecordPattern(
+        matchedType, typeInfos, 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(
+      'recordPattern',
+      [...List.filled(fields.length, Kind.pattern), Kind.type, Kind.type],
+      Kind.pattern,
+      names: ['matchedType', 'requiredType'],
+      location: location,
+    );
+  }
+
+  @override
+  String _debugString({required bool needsKeywordOrType}) {
+    var fieldStrings = [
+      for (var field in fields)
+        field.pattern._debugString(needsKeywordOrType: needsKeywordOrType)
+    ];
+    return '(${fieldStrings.join(', ')})';
+  }
+}
+
 class _RelationalPattern extends Pattern {
   final RelationalOperatorResolution<Type>? operator;
   final Expression operand;