Version 2.19.0-398.0.dev

Merge 933cba6 into dev

Author: Dart CI

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -9304,7 +9304,7 @@ class Parser {
     // TODO(paulberry): Make sure OTHER_IDENTIFIER is handled
     // TODO(paulberry): Technically `dynamic` is valid for
     // `typeIdentifier`--file an issue
-    if (isValidNonRecordTypeReference(next)) {
+    if (next.isIdentifier) {
       Token beforeFirstIdentifier = token;
       Token firstIdentifier = token = next;
       next = token.next!;
@@ -9313,7 +9313,7 @@ class Parser {
       if (optional('.', next)) {
         dot = token = next;
         next = token.next!;
-        if (isValidNonRecordTypeReference(next)) {
+        if (next.isIdentifier) {
           secondIdentifier = token = next;
           // TODO(paulberry): grammar specifies
           // `typeIdentifier | qualifiedName`, but that permits `a.b.c`,

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

@@ -360,12 +360,14 @@ mixin TypeAnalyzer<
   /// the expression, [pattern] for the pattern to match, [ifTrue] for the
   /// "then" branch, and [ifFalse] for the "else" branch (if present).
   ///
+  /// Returns the static type of [expression].
+  ///
   /// Stack effect: pushes (Expression scrutinee, Pattern, Expression guard,
   /// Statement ifTrue, Statement ifFalse).  If there is no `else` clause, the
   /// representation for `ifFalse` will be pushed by [handleNoStatement].  If
   /// there is no guard, the representation for `guard` will be pushed by
   /// [handleNoGuard].
-  void analyzeIfCaseStatement(
+  Type analyzeIfCaseStatement(
       Statement node,
       Expression expression,
       Pattern pattern,
@@ -391,6 +393,7 @@ mixin TypeAnalyzer<
     // Stack: (Expression, Pattern, Guard)
     flow?.ifStatement_thenBegin(null, node);
     _analyzeIfCommon(node, ifTrue, ifFalse);
+    return initializerType;
   }
 
   /// Analyzes a collection element of the form `if (condition) ifTrue` or
@@ -1062,6 +1065,8 @@ mixin TypeAnalyzer<
   /// If this is a wildcard pattern (it doesn't bind any variable), [variable]
   /// should be `null`.
   ///
+  /// Returns the static type of the variable (possibly inferred).
+  ///
   /// Stack effect: none.
   Type analyzeVariablePattern(
     Type matchedType,

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -1505,7 +1505,8 @@ class _CheckAssigned extends Statement {
 
   @override
   void visit(Harness h) {
-    expect(h.flow.isAssigned(variable), expectedAssignedState);
+    expect(h.flow.isAssigned(variable), expectedAssignedState,
+        reason: 'at $location');
     h.irBuilder.atom('null', Kind.statement, location: location);
   }
 }

pkg/analyzer/lib/src/error/use_result_verifier.dart

@@ -73,6 +73,9 @@ class UseResultVerifier {
       // Don't flag references in comments.
       return;
     }
+    if (parent is ShowCombinator || parent is HideCombinator) {
+      return;
+    }
 
     var annotation = _getUseResultMetadata(element);
     if (annotation == null) {

pkg/analyzer/test/generated/patterns_parser_test.dart

@@ -956,6 +956,32 @@ RecordPattern
 ''');
   }
 
+  test_constant_identifier_doublyPrefixed_builtin() {
+    _parse('''
+void f(x) {
+  const y = abstract.as.get; // verify that this works
+  switch (x) {
+    case abstract.as.get:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case abstract.as.get').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: PropertyAccess
+    target: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: abstract
+      period: .
+      identifier: SimpleIdentifier
+        token: as
+    operator: .
+    propertyName: SimpleIdentifier
+      token: get
+''');
+  }
+
   test_constant_identifier_doublyPrefixed_insideCase() {
     _parse('''
 void f(x) {
@@ -1089,6 +1115,54 @@ PostfixPattern
 ''');
   }
 
+  test_constant_identifier_doublyPrefixed_pseudoKeyword() {
+    _parse('''
+void f(x) {
+  const y = show.hide.when; // verify that this works
+  switch (x) {
+    case show.hide.when:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case show.hide.when').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: PropertyAccess
+    target: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: show
+      period: .
+      identifier: SimpleIdentifier
+        token: hide
+    operator: .
+    propertyName: SimpleIdentifier
+      token: when
+''');
+  }
+
+  test_constant_identifier_prefixed_builtin() {
+    _parse('''
+void f(x) {
+  const y = abstract.as; // verify that this works
+  switch (x) {
+    case abstract.as:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case abstract.as').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: PrefixedIdentifier
+    prefix: SimpleIdentifier
+      token: abstract
+    period: .
+    identifier: SimpleIdentifier
+      token: as
+''');
+  }
+
   test_constant_identifier_prefixed_insideCase() {
     _parse('''
 void f(x) {
@@ -1202,6 +1276,28 @@ PostfixPattern
 ''');
   }
 
+  test_constant_identifier_prefixed_pseudoKeyword() {
+    _parse('''
+void f(x) {
+  const y = show.hide; // verify that this works
+  switch (x) {
+    case show.hide:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case show.hide').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: PrefixedIdentifier
+    prefix: SimpleIdentifier
+      token: show
+    period: .
+    identifier: SimpleIdentifier
+      token: hide
+''');
+  }
+
   test_constant_identifier_prefixedWithUnderscore_insideCase() {
     // We need to make sure the `_` isn't misinterpreted as a wildcard pattern
     _parse('''
@@ -1224,6 +1320,24 @@ ConstantPattern
 ''');
   }
 
+  test_constant_identifier_unprefixed_builtin() {
+    _parse('''
+void f(x) {
+  const y = abstract; // verify that this works
+  switch (x) {
+    case abstract:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case abstract').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: SimpleIdentifier
+    token: abstract
+''');
+  }
+
   test_constant_identifier_unprefixed_insideCase() {
     _parse('''
 void f(x) {
@@ -1322,6 +1436,24 @@ PostfixPattern
 ''');
   }
 
+  test_constant_identifier_unprefixed_pseudoKeyword() {
+    _parse('''
+void f(x) {
+  const y = show; // verify that this works
+  switch (x) {
+    case show:
+      break;
+  }
+}
+''');
+    var node = findNode.switchPatternCase('case show').pattern;
+    assertParsedNodeText(node, '''
+ConstantPattern
+  expression: SimpleIdentifier
+    token: show
+''');
+  }
+
   test_constant_list_typed_empty_insideCase() {
     _parse('''
 void f(x) {

pkg/analyzer/test/src/diagnostics/unused_result_test.dart

@@ -619,6 +619,42 @@ void main() {
     ]);
   }
 
+  test_import_hide() async {
+    newFile('$testPackageLibPath/a.dart', r'''
+import 'package:meta/meta.dart';
+
+@useResult
+bool foo() => true;
+
+bool bar() => true;
+''');
+
+    await assertNoErrorsInCode(r'''
+import 'a.dart' hide foo;
+
+bool f() {
+  return bar();
+}
+''');
+  }
+
+  test_import_show() async {
+    newFile('$testPackageLibPath/a.dart', r'''
+import 'package:meta/meta.dart';
+
+@useResult
+bool foo() => true;
+''');
+
+    await assertNoErrorsInCode(r'''
+import 'a.dart' show foo;
+
+bool f() {
+  return foo();
+}
+''');
+  }
+
   test_method_result_assertInitializer() async {
     await assertNoErrorsInCode('''
 import 'package:meta/meta.dart';

pkg/dart2wasm/lib/class_info.dart

@@ -197,15 +197,13 @@ class ClassInfoCollector {
         }
 
         // In the Wasm type hierarchy, Object, bool and num sit directly below
-        // the Top type. The implementation classes (_StringBase, _Type and the
-        // box classes) sit directly below the public classes they implement.
+        // the Top type. The implementation classes _StringBase and _Type sit
+        // directly below the public classes they implement.
         // All other classes sit below their superclass.
         ClassInfo superInfo = cls == translator.coreTypes.boolClass ||
                 cls == translator.coreTypes.numClass
             ? topInfo
-            : cls == translator.stringBaseClass ||
-                    cls == translator.typeClass ||
-                    translator.boxedClasses.values.contains(cls)
+            : cls == translator.stringBaseClass || cls == translator.typeClass
                 ? translator.classInfo[cls.implementedTypes.single.classNode]!
                 : translator.classInfo[superclass]!;
 

pkg/dart2wasm/lib/intrinsics.dart

@@ -38,6 +38,11 @@ class Intrinsifier {
         '<=': (b) => b.i64_le_s(),
         '>': (b) => b.i64_gt_s(),
         '>=': (b) => b.i64_ge_s(),
+        '_div_s': (b) => b.i64_div_s(),
+        '_shl': (b) => b.i64_shl(),
+        '_shr_s': (b) => b.i64_shr_s(),
+        '_shr_u': (b) => b.i64_shr_u(),
+        '_lt_u': (b) => b.i64_lt_u(),
       }
     },
     doubleType: {
@@ -81,13 +86,17 @@ class Intrinsifier {
       'truncateToDouble': (b) {
         b.f64_trunc();
       },
+      '_toInt': (b) {
+        b.i64_trunc_sat_f64_s();
+      },
     },
   };
   static final Map<String, w.ValueType> unaryResultMap = {
     'toDouble': w.NumType.f64,
     'floorToDouble': w.NumType.f64,
     'ceilToDouble': w.NumType.f64,
     'truncateToDouble': w.NumType.f64,
+    '_toInt': w.NumType.i64,
   };
 
   Translator get translator => codeGen.translator;
@@ -100,7 +109,7 @@ class Intrinsifier {
   }
 
   static bool isComparison(String op) =>
-      op == '<' || op == '<=' || op == '>' || op == '>=';
+      op == '<' || op == '<=' || op == '>' || op == '>=' || op == '_lt_u';
 
   Intrinsifier(this.codeGen);
 
@@ -715,58 +724,6 @@ class Intrinsifier {
           codeGen.wrap(typeArguments, translator.types.typeListExpectedType);
           b.struct_new(info.struct);
           return info.nonNullableType;
-        case "_div_s":
-          assert(cls == translator.boxedIntClass);
-          assert(node.arguments.positional.length == 2);
-          Expression first = node.arguments.positional[0];
-          Expression second = node.arguments.positional[1];
-          codeGen.wrap(first, w.NumType.i64);
-          codeGen.wrap(second, w.NumType.i64);
-          b.i64_div_s();
-          return w.NumType.i64;
-        case "_shl":
-          assert(cls == translator.boxedIntClass);
-          assert(node.arguments.positional.length == 2);
-          Expression first = node.arguments.positional[0];
-          Expression second = node.arguments.positional[1];
-          codeGen.wrap(first, w.NumType.i64);
-          codeGen.wrap(second, w.NumType.i64);
-          b.i64_shl();
-          return w.NumType.i64;
-        case "_shr_s":
-          assert(cls == translator.boxedIntClass);
-          assert(node.arguments.positional.length == 2);
-          Expression first = node.arguments.positional[0];
-          Expression second = node.arguments.positional[1];
-          codeGen.wrap(first, w.NumType.i64);
-          codeGen.wrap(second, w.NumType.i64);
-          b.i64_shr_s();
-          return w.NumType.i64;
-        case "_shr_u":
-          assert(cls == translator.boxedIntClass);
-          assert(node.arguments.positional.length == 2);
-          Expression first = node.arguments.positional[0];
-          Expression second = node.arguments.positional[1];
-          codeGen.wrap(first, w.NumType.i64);
-          codeGen.wrap(second, w.NumType.i64);
-          b.i64_shr_u();
-          return w.NumType.i64;
-        case "_lt_u":
-          assert(cls == translator.boxedIntClass);
-          assert(node.arguments.positional.length == 2);
-          Expression first = node.arguments.positional[0];
-          Expression second = node.arguments.positional[1];
-          codeGen.wrap(first, w.NumType.i64);
-          codeGen.wrap(second, w.NumType.i64);
-          b.i64_lt_u();
-          return w.NumType.i32; // bool
-        case "_toInt":
-          assert(cls == translator.boxedDoubleClass);
-          assert(node.arguments.positional.length == 1);
-          Expression arg = node.arguments.positional[0];
-          codeGen.wrap(arg, w.NumType.f64);
-          b.i64_trunc_sat_f64_s();
-          return w.NumType.i64;
       }
     }