Version 2.11.0-186.0.dev

Merge commit '78e30b039e07fb0a16e5972caf6f5543fd13e9c8' into 'dev'

Author: Dart CI

DEPS

@@ -44,7 +44,7 @@ vars = {
   # co19 is a cipd package. Use update.sh in tests/co19[_2] to update these
   # hashes. It requires access to the dart-build-access group, which EngProd
   # has.
-  "co19_rev": "53dd55a31d345320a6aa2b6eea0467f868b72377",
+  "co19_rev": "01adc3471b81d3bceb9bbe775ed1262b1b89cc8a",
   "co19_2_rev": "e48b3090826cf40b8037648f19d211e8eab1b4b6",
 
   # The internal benchmarks to use. See go/dart-benchmarks-internal
@@ -529,7 +529,7 @@ deps = {
     "packages": [
       {
         "package": "dart/cfe/dart2js_dills",
-        "version": "binary_version:45",
+        "version": "binary_version:46",
       }
     ],
     "dep_type": "cipd",

pkg/analyzer/lib/error/error.dart

@@ -260,6 +260,7 @@ const List<ErrorCode> errorCodeValues = [
   CompileTimeErrorCode.LATE_FINAL_FIELD_WITH_CONST_CONSTRUCTOR,
   CompileTimeErrorCode.LATE_FINAL_LOCAL_ALREADY_ASSIGNED,
   CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE,
+  CompileTimeErrorCode.MAIN_IS_NOT_FUNCTION,
   CompileTimeErrorCode.MAP_ENTRY_NOT_IN_MAP,
   CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE,
   CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE,

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

@@ -413,20 +413,14 @@ class BestPracticesVerifier extends RecursiveAstVisitor<void> {
               [field.name, overriddenElement.enclosingElement.name]);
         }
 
-        var expression = field.initializer;
-
-        var element = _getElement(expression);
-        if (element != null) {
-          if (element is PropertyAccessorElement && element.isSynthetic) {
-            element = (element as PropertyAccessorElement).variable;
-          }
-          if (element.hasOrInheritsDoNotStore) {
-            _errorReporter.reportErrorForNode(
-              HintCode.ASSIGNMENT_OF_DO_NOT_STORE,
-              expression,
-              [element.name],
-            );
-          }
+        var expressionMap =
+            _getSubExpressionsMarkedDoNotStore(field.initializer);
+        for (var entry in expressionMap.entries) {
+          _errorReporter.reportErrorForNode(
+            HintCode.ASSIGNMENT_OF_DO_NOT_STORE,
+            entry.key,
+            [entry.value.name],
+          );
         }
       }
     } finally {
@@ -1382,15 +1376,17 @@ class BestPracticesVerifier extends RecursiveAstVisitor<void> {
     if (_inDoNotStoreMember) {
       return;
     }
-    var element = _getElement(expression);
-    if (element != null && element.hasOrInheritsDoNotStore) {
+    var expressionMap = _getSubExpressionsMarkedDoNotStore(expression);
+    if (expressionMap.isNotEmpty) {
       Declaration parent = expression.thisOrAncestorMatching(
           (e) => e is FunctionDeclaration || e is MethodDeclaration);
-      _errorReporter.reportErrorForNode(
-        HintCode.RETURN_OF_DO_NOT_STORE,
-        expression,
-        [element.name, parent.declaredElement.displayName],
-      );
+      for (var entry in expressionMap.entries) {
+        _errorReporter.reportErrorForNode(
+          HintCode.RETURN_OF_DO_NOT_STORE,
+          entry.key,
+          [entry.value.name, parent.declaredElement.displayName],
+        );
+      }
     }
   }
 
@@ -1537,7 +1533,13 @@ class BestPracticesVerifier extends RecursiveAstVisitor<void> {
     }
   }
 
-  Element _getElement(Expression expression) {
+  /// Return subexpressions that are marked `@doNotStore`, as a map so that
+  /// corresponding elements can be used in the diagnostic message.
+  Map<Expression, Element> _getSubExpressionsMarkedDoNotStore(
+      Expression expression,
+      {Map<Expression, Element> addTo}) {
+    var expressions = addTo ?? <Expression, Element>{};
+
     Element element;
     if (expression is PropertyAccess) {
       element = expression.propertyName.staticElement;
@@ -1553,13 +1555,26 @@ class BestPracticesVerifier extends RecursiveAstVisitor<void> {
       if (element is FunctionElement || element is MethodElement) {
         element = null;
       }
+    } else if (expression is ConditionalExpression) {
+      _getSubExpressionsMarkedDoNotStore(expression.elseExpression,
+          addTo: expressions);
+      _getSubExpressionsMarkedDoNotStore(expression.thenExpression,
+          addTo: expressions);
+    } else if (expression is BinaryExpression) {
+      _getSubExpressionsMarkedDoNotStore(expression.leftOperand,
+          addTo: expressions);
+      _getSubExpressionsMarkedDoNotStore(expression.rightOperand,
+          addTo: expressions);
     }
-    if (element != null) {
-      if (element is PropertyAccessorElement && element.isSynthetic) {
-        element = (element as PropertyAccessorElement).variable;
-      }
+    if (element is PropertyAccessorElement && element.isSynthetic) {
+      element = (element as PropertyAccessorElement).variable;
     }
-    return element;
+
+    if (element != null && element.hasOrInheritsDoNotStore) {
+      expressions[expression] = element;
+    }
+
+    return expressions;
   }
 
   bool _isLibraryInWorkspacePackage(LibraryElement library) {

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

@@ -5460,6 +5460,12 @@ class CompileTimeErrorCode extends AnalyzerErrorCode {
           "The element type '{0}' can't be assigned to the list type '{1}'.",
           hasPublishedDocs: true);
 
+  static const CompileTimeErrorCode MAIN_IS_NOT_FUNCTION = CompileTimeErrorCode(
+    'MAIN_IS_NOT_FUNCTION',
+    "The declaration named 'main' must be a function.",
+    correction: "Try using a different name for this declaration.",
+  );
+
   /**
    * No parameters.
    */

pkg/analyzer/lib/src/generated/error_verifier.dart

@@ -449,6 +449,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
       _checkForFinalNotInitializedInClass(members);
       _checkForBadFunctionUse(node);
       _checkForWrongTypeParameterVarianceInSuperinterfaces();
+      _checkForMainFunction(node.name);
       super.visitClassDeclaration(node);
     } finally {
       _isInNativeClass = false;
@@ -466,6 +467,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
       _enclosingClass = node.declaredElement;
       _checkClassInheritance(
           node, node.superclass, node.withClause, node.implementsClause);
+      _checkForMainFunction(node.name);
       _checkForWrongTypeParameterVarianceInSuperinterfaces();
     } finally {
       _enclosingClass = outerClassElement;
@@ -724,6 +726,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
       _checkForTypeAnnotationDeferredClass(returnType);
       _returnTypeVerifier.verifyReturnType(returnType);
       _checkForImplicitDynamicReturn(node.name, node.declaredElement);
+      _checkForMainFunction(node.name);
       super.visitFunctionDeclaration(node);
     });
   }
@@ -770,6 +773,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
   void visitFunctionTypeAlias(FunctionTypeAlias node) {
     _checkForBuiltInIdentifierAsName(
         node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
+    _checkForMainFunction(node.name);
     _checkForTypeAliasCannotReferenceItself(node, node.declaredElement);
     super.visitFunctionTypeAlias(node);
   }
@@ -805,6 +809,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
   void visitGenericTypeAlias(GenericTypeAlias node) {
     _checkForBuiltInIdentifierAsName(
         node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
+    _checkForMainFunction(node.name);
     _checkForTypeAliasCannotReferenceItself(node, node.declaredElement);
     super.visitGenericTypeAlias(node);
   }
@@ -970,6 +975,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
 
       _checkForConflictingClassMembers();
       _checkForFinalNotInitializedInClass(members);
+      _checkForMainFunction(node.name);
       _checkForWrongTypeParameterVarianceInSuperinterfaces();
       //      _checkForBadFunctionUse(node);
       super.visitMixinDeclaration(node);
@@ -1193,6 +1199,11 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
   void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _checkForFinalNotInitialized(node.variables);
     _checkForNotInitializedNonNullableVariable(node.variables);
+
+    for (var declaration in node.variables.variables) {
+      _checkForMainFunction(declaration.name);
+    }
+
     super.visitTopLevelVariableDeclaration(node);
   }
 
@@ -3094,6 +3105,31 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
     }
   }
 
+  void _checkForMainFunction(SimpleIdentifier nameNode) {
+    if (!_currentLibrary.isNonNullableByDefault) {
+      return;
+    }
+
+    var element = nameNode.staticElement;
+
+    // We should only check exported declarations, i.e. top-level.
+    if (element.enclosingElement is! CompilationUnitElement) {
+      return;
+    }
+
+    if (element.displayName != 'main') {
+      return;
+    }
+
+    if (element is! FunctionElement) {
+      _errorReporter.reportErrorForNode(
+        CompileTimeErrorCode.MAIN_IS_NOT_FUNCTION,
+        nameNode,
+      );
+      return;
+    }
+  }
+
   void _checkForMapTypeNotAssignable(SetOrMapLiteral literal) {
     // Determine the map's key and value types. We base this on the static type
     // and not the literal's type arguments because in strong mode, the type

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

@@ -34,7 +34,8 @@ class B {
   String f = A().v;
 }
 ''', [
-      error(HintCode.ASSIGNMENT_OF_DO_NOT_STORE, 106, 5),
+      error(HintCode.ASSIGNMENT_OF_DO_NOT_STORE, 106, 5,
+          messageContains: "'v'"),
     ]);
   }
 
@@ -176,4 +177,59 @@ class A {
       error(HintCode.ASSIGNMENT_OF_DO_NOT_STORE, 83, 1),
     ]);
   }
+
+  test_topLevelVariable_binaryExpression() async {
+    await assertErrorsInCode('''
+import 'package:meta/meta.dart';
+
+@doNotStore
+final v = '';
+
+class A {
+  final f = v ?? v;
+}
+''', [
+      error(HintCode.ASSIGNMENT_OF_DO_NOT_STORE, 83, 1),
+      error(HintCode.ASSIGNMENT_OF_DO_NOT_STORE, 88, 1),
+    ]);
+  }
+
+  test_topLevelVariable_libraryAnnotation() async {
+    testFilePath;
+    newFile('$testPackageLibPath/library.dart', content: '''
+@doNotStore
+library lib;
+
+import 'package:meta/meta.dart';
+
+final v = '';
+''');
+
+    await assertErrorsInCode('''
+import 'library.dart';
+
+class A {
+  final f = v;
+}
+''', [
+      error(HintCode.ASSIGNMENT_OF_DO_NOT_STORE, 46, 1),
+    ]);
+  }
+
+  test_topLevelVariable_ternary() async {
+    await assertErrorsInCode('''
+import 'package:meta/meta.dart';
+
+@doNotStore
+final v = '';
+
+class A {
+  static bool c;
+  final f = c ? v : v;
+}
+''', [
+      error(HintCode.ASSIGNMENT_OF_DO_NOT_STORE, 104, 1),
+      error(HintCode.ASSIGNMENT_OF_DO_NOT_STORE, 108, 1),
+    ]);
+  }
 }

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

@@ -0,0 +1,97 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// 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 '../dart/resolution/context_collection_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(MainIsNotFunctionTest);
+    defineReflectiveTests(MainIsNotFunctionWithNullSafetyTest);
+  });
+}
+
+@reflectiveTest
+class MainIsNotFunctionTest extends PubPackageResolutionTest
+    with MainIsNotFunctionTestCases {}
+
+mixin MainIsNotFunctionTestCases on PubPackageResolutionTest {
+  test_class() async {
+    await resolveTestCode('''
+class main {}
+''');
+    assertErrorsInResult(expectedErrorsByNullability(nullable: [
+      error(CompileTimeErrorCode.MAIN_IS_NOT_FUNCTION, 6, 4),
+    ], legacy: []));
+  }
+
+  test_classAlias() async {
+    await resolveTestCode('''
+class A {}
+mixin M {}
+class main = A with M;
+''');
+    assertErrorsInResult(expectedErrorsByNullability(nullable: [
+      error(CompileTimeErrorCode.MAIN_IS_NOT_FUNCTION, 28, 4),
+    ], legacy: []));
+  }
+
+  test_function() async {
+    await assertNoErrorsInCode('''
+void main() {}
+''');
+  }
+
+  test_getter() async {
+    await resolveTestCode('''
+int get main => 0;
+''');
+    assertErrorsInResult(expectedErrorsByNullability(nullable: [
+      error(CompileTimeErrorCode.MAIN_IS_NOT_FUNCTION, 8, 4),
+    ], legacy: []));
+  }
+
+  test_mixin() async {
+    await resolveTestCode('''
+class A {}
+mixin main on A {}
+''');
+    assertErrorsInResult(expectedErrorsByNullability(nullable: [
+      error(CompileTimeErrorCode.MAIN_IS_NOT_FUNCTION, 17, 4),
+    ], legacy: []));
+  }
+
+  test_typedef() async {
+    await resolveTestCode('''
+typedef main = void Function();
+''');
+    assertErrorsInResult(expectedErrorsByNullability(nullable: [
+      error(CompileTimeErrorCode.MAIN_IS_NOT_FUNCTION, 8, 4),
+    ], legacy: []));
+  }
+
+  test_typedef_legacy() async {
+    await resolveTestCode('''
+typedef void main();
+''');
+    assertErrorsInResult(expectedErrorsByNullability(nullable: [
+      error(CompileTimeErrorCode.MAIN_IS_NOT_FUNCTION, 13, 4),
+    ], legacy: []));
+  }
+
+  test_variable() async {
+    await resolveTestCode('''
+var main = 0;
+''');
+    assertErrorsInResult(expectedErrorsByNullability(nullable: [
+      error(CompileTimeErrorCode.MAIN_IS_NOT_FUNCTION, 4, 4),
+    ], legacy: []));
+  }
+}
+
+@reflectiveTest
+class MainIsNotFunctionWithNullSafetyTest extends PubPackageResolutionTest
+    with WithNullSafetyMixin, MainIsNotFunctionTestCases {}