Report EXTENSION_AS_EXPRESSION, set type fo dynamic.

R=brianwilkerson@google.com

Bug: dart-lang/sdk#38203
Change-Id: Iee270b7b3fecbeaba202c304f21ef703a8567674
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/116055
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>

pkg/analyzer/lib/error/error.dart

@@ -137,6 +137,7 @@ const List<ErrorCode> errorCodeValues = const [
   CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS,
   CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
   CompileTimeErrorCode.EXTENDS_NON_CLASS,
+  CompileTimeErrorCode.EXTENSION_AS_EXPRESSION,
   CompileTimeErrorCode.EXTENSION_CONFLICTING_STATIC_AND_INSTANCE,
   CompileTimeErrorCode.EXTENSION_DECLARES_MEMBER_OF_OBJECT,
   CompileTimeErrorCode.EXTENSION_OVERRIDE_ACCESS_TO_STATIC_MEMBER,

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

@@ -1279,6 +1279,15 @@ class CompileTimeErrorCode extends AnalyzerErrorCode {
           correction: "Try specifying a different superclass, or "
               "removing the extends clause.");
 
+  /**
+   * Parameters:
+   * 0: the name of the extension
+   */
+  static const CompileTimeErrorCode EXTENSION_AS_EXPRESSION =
+      const CompileTimeErrorCode('EXTENSION_AS_EXPRESSION',
+          "Extension '{0}' can't be used as an expression.",
+          correction: "Try replacing it with a valid expression.");
+
   /**
    * It is for an extension to define a static member and an instance member
    * with the same base name.

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

@@ -857,6 +857,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     Element staticElement = prefixedIdentifier.staticElement;
 
     if (staticElement is ExtensionElement) {
+      _setExtensionIdentifierType(node);
       return;
     }
 
@@ -1092,6 +1093,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     Element element = node.staticElement;
 
     if (element is ExtensionElement) {
+      _setExtensionIdentifierType(node);
       return;
     }
 
@@ -2043,6 +2045,40 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     }
   }
 
+  void _setExtensionIdentifierType(Identifier node) {
+    if (node is SimpleIdentifier && node.inDeclarationContext()) {
+      return;
+    }
+
+    var parent = node.parent;
+
+    if (parent is PrefixedIdentifier && parent.identifier == node) {
+      node = parent;
+      parent = node.parent;
+    }
+
+    if (parent is CommentReference ||
+        parent is ExtensionOverride && parent.extensionName == node ||
+        parent is MethodInvocation && parent.target == node ||
+        parent is PrefixedIdentifier && parent.prefix == node ||
+        parent is PropertyAccess && parent.target == node) {
+      return;
+    }
+
+    _resolver.errorReporter.reportErrorForNode(
+      CompileTimeErrorCode.EXTENSION_AS_EXPRESSION,
+      node,
+      [node.name],
+    );
+
+    if (node is PrefixedIdentifier) {
+      node.identifier.staticType = _dynamicType;
+      node.staticType = _dynamicType;
+    } else if (node is SimpleIdentifier) {
+      node.staticType = _dynamicType;
+    }
+  }
+
   DartType _toMapType(SetOrMapLiteral node, DartType contextType,
       List<_InferredCollectionElementTypeInformation> inferredTypes) {
     DartType dynamicType = _typeProvider.dynamicType;

pkg/analyzer/test/generated/invalid_code_test.dart

@@ -4,7 +4,9 @@
 
 import 'dart:async';
 
+import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../src/dart/resolution/driver_resolution.dart';
@@ -16,6 +18,7 @@ main() {
     } else {
       defineReflectiveTests(InvalidCodeTest);
     }
+    defineReflectiveTests(InvalidCodeWithExtensionMethodsTest);
   });
 }
 
@@ -219,3 +222,29 @@ class C {
     assertHasTestErrors();
   }
 }
+
+@reflectiveTest
+class InvalidCodeWithExtensionMethodsTest extends DriverResolutionTest {
+  @override
+  AnalysisOptionsImpl get analysisOptions => AnalysisOptionsImpl()
+    ..contextFeatures = new FeatureSet.forTesting(
+        sdkVersion: '2.3.0', additionalFeatures: [Feature.extension_methods]);
+
+  @failingTest
+  test_fuzz_14() async {
+    // This crashes because parser produces `ConstructorDeclaration`.
+    // So, we try to create `ConstructorElement` for it, and it wants
+    // `ClassElement` as the enclosing element. But we have `ExtensionElement`.
+    await _assertCanBeAnalyzed(r'''
+extension E {
+  factory S() {}
+}
+''');
+  }
+
+  Future<void> _assertCanBeAnalyzed(String text) async {
+    addTestFile(text);
+    await resolveTestFile();
+    assertHasTestErrors();
+  }
+}

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

@@ -0,0 +1,48 @@
+// Copyright (c) 2019, 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/dart/analysis/features.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../dart/resolution/driver_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ExtensionAsExpressionTest);
+  });
+}
+
+@reflectiveTest
+class ExtensionAsExpressionTest extends DriverResolutionTest {
+  @override
+  AnalysisOptionsImpl get analysisOptions => AnalysisOptionsImpl()
+    ..contextFeatures = new FeatureSet.forTesting(
+        sdkVersion: '2.3.0', additionalFeatures: [Feature.extension_methods]);
+
+  test_prefixedIdentifier() async {
+    newFile('/test/lib/a.dart', content: r'''
+extension E on int {}
+''');
+    await assertErrorsInCode('''
+import 'a.dart' as p;
+var v = p.E;
+''', [
+      error(CompileTimeErrorCode.EXTENSION_AS_EXPRESSION, 30, 3),
+    ]);
+    assertTypeDynamic(findNode.simple('E;'));
+    assertTypeDynamic(findNode.prefixed('p.E;'));
+  }
+
+  test_simpleIdentifier() async {
+    await assertErrorsInCode('''
+extension E on int {}
+var v = E;
+''', [
+      error(CompileTimeErrorCode.EXTENSION_AS_EXPRESSION, 30, 1),
+    ]);
+    assertTypeDynamic(findNode.simple('E;'));
+  }
+}

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

@@ -2,14 +2,17 @@
 // 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/analysis/features.dart';
 import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../dart/resolution/driver_resolution.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(NotATypeTest);
+    defineReflectiveTests(NotATypeWithExtensionMethodsTest);
   });
 }
 
@@ -26,3 +29,19 @@ main() {
     ]);
   }
 }
+
+@reflectiveTest
+class NotATypeWithExtensionMethodsTest extends NotATypeTest {
+  @override
+  AnalysisOptionsImpl get analysisOptions => AnalysisOptionsImpl()
+    ..contextFeatures = new FeatureSet.forTesting(
+        sdkVersion: '2.3.0', additionalFeatures: [Feature.extension_methods]);
+
+  test_extension() async {
+    await assertErrorsInCode('''
+extension E on int {}
+E a;
+''', [error(StaticWarningCode.NOT_A_TYPE, 22, 1)]);
+    assertTypeDynamic(findNode.simple('E a;'));
+  }
+}

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

@@ -65,6 +65,7 @@ import 'export_suplicated_library_named_test.dart'
     as export_suplicated_library_named;
 import 'expression_in_map_test.dart' as expression_in_map;
 import 'extends_non_class_test.dart' as extends_non_class;
+import 'extension_as_expression_test.dart' as extension_as_expression;
 import 'extension_conflicting_static_and_instance_test.dart'
     as extension_conflicting_static_and_instance;
 import 'extension_declares_abstract_method_test.dart'
@@ -353,6 +354,7 @@ main() {
     export_suplicated_library_named.main();
     expression_in_map.main();
     extends_non_class.main();
+    extension_as_expression.main();
     extension_conflicting_static_and_instance.main();
     extension_declares_abstract_method.main();
     extension_declares_constructor.main();