Issue 24503. Disable type overrides for properties.

pkg/analyzer/test/generated/resolver_test.dart

 // Copyright (c) 2014, 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.
 
 library engine.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 977 matching lines @@
     ]);
     verify([source]);
   }
 
   void test_fieldTypeMismatch_generic() {
     Source source = addSource(r'''
 class C<T> {
   final T x = y;
   const C();
 }
-const y = 1;
+const int y = 1;
 var v = const C<String>();
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
-      HintCode.INVALID_ASSIGNMENT
+      StaticTypeWarningCode.INVALID_ASSIGNMENT
     ]);
     verify([source]);
   }
 
   void test_fieldTypeMismatch_unresolved() {
     Source source = addSource(r'''
 class A {
   const A(x) : y = x;
   final Unresolved y;
 }
 var v = const A('foo');''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [
       CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
       StaticWarningCode.UNDEFINED_CLASS
     ]);
     verify([source]);
   }
 
   void test_fieldTypeOk_generic() {
     Source source = addSource(r'''
 class C<T> {
   final T x = y;
   const C();
 }
-const y = 1;
+const int y = 1;
 var v = const C<int>();
 ''');
     computeLibrarySourceErrors(source);
-    assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_fieldTypeOk_null() {
     Source source = addSource(r'''
 class A {
   const A(x) : y = x;
   final int y;
 }
 var v = const A(null);''');
@@ skipping 8922 matching lines @@
     }
   }
 }
 
 class SourceContainer_ChangeSetTest_test_toString implements SourceContainer {
   @override
   bool contains(Source source) => false;
 }
 
 /**
- * Shared infrastructure for [StaticTypeAnalyzer2Test] and
- * [StrongModeStaticTypeAnalyzer2Test].
- */
-class _StaticTypeAnalyzer2TestShared extends ResolverTestCase {
-  String testCode;
-  Source testSource;
-  CompilationUnit testUnit;
-
-  SimpleIdentifier _findIdentifier(String search) {
-    SimpleIdentifier identifier = EngineTestCase.findNode(
-        testUnit, testCode, search, (node) => node is SimpleIdentifier);
-    return identifier;
-  }
-
-  void _resolveTestUnit(String code) {
-    testCode = code;
-    testSource = addSource(testCode);
-    LibraryElement library = resolve2(testSource);
-    assertNoErrors(testSource);
-    verify([testSource]);
-    testUnit = resolveCompilationUnit(testSource, library);
-  }
-}
-
-/**
  * Like [StaticTypeAnalyzerTest], but as end-to-end tests.
  */
 @reflectiveTest
 class StaticTypeAnalyzer2Test extends _StaticTypeAnalyzer2TestShared {
   void test_FunctionExpressionInvocation_block() {
     String code = r'''
 main() {
   var foo = (() { return 1; })();
 }
 ''';
@@ skipping 1896 matching lines @@
  * Strong mode static analyzer end to end tests
  */
 @reflectiveTest
 class StrongModeStaticTypeAnalyzer2Test extends _StaticTypeAnalyzer2TestShared {
   void setUp() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
     resetWithOptions(options);
   }
 
-  void test_ternaryOperator_null_right() {
+  void test_dynamicObjectGetter_hashCode() {
     String code = r'''
 main() {
-  var foo = (true) ? 3 : null;
+  dynamic a = null;
+  var foo = a.hashCode;
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
     expect(declaration.initializer.staticType.name, 'int');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
-  void test_ternaryOperator_null_left() {
+  void test_dynamicObjectMethod_toString() {
     String code = r'''
 main() {
-  var foo = (true) ? null : 3;
+  dynamic a = null;
+  var foo = a.toString();
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
-    expect(declaration.initializer.staticType.name, 'int');
+    expect(declaration.initializer.staticType.name, 'String');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
-  void test_dynamicObjectMethod_toString() {
+  void test_pseudoGeneric_max_doubleDouble() {
     String code = r'''
+import 'dart:math';
 main() {
-  dynamic a = null;
-  var foo = a.toString();
+  var foo = max(1.0, 2.0);
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
-    expect(declaration.initializer.staticType.name, 'String');
+    expect(declaration.initializer.staticType.name, 'double');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
-  void test_dynamicObjectGetter_hashCode() {
+  void test_pseudoGeneric_max_doubleInt() {
     String code = r'''
+import 'dart:math';
 main() {
-  dynamic a = null;
-  var foo = a.hashCode;
+  var foo = max(1.0, 2);
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
-    expect(declaration.initializer.staticType.name, 'int');
+    expect(declaration.initializer.staticType.name, 'num');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
-  void test_pseudoGeneric_max_intInt() {
+  void test_pseudoGeneric_max_intDouble() {
     String code = r'''
 import 'dart:math';
 main() {
-  var foo = max(1, 2);
+  var foo = max(1, 2.0);
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
-    expect(declaration.initializer.staticType.name, 'int');
+    expect(declaration.initializer.staticType.name, 'num');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
-  void test_pseudoGeneric_max_doubleDouble() {
+  void test_pseudoGeneric_max_intInt() {
     String code = r'''
 import 'dart:math';
 main() {
-  var foo = max(1.0, 2.0);
+  var foo = max(1, 2);
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
-    expect(declaration.initializer.staticType.name, 'double');
+    expect(declaration.initializer.staticType.name, 'int');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
-  void test_pseudoGeneric_max_intDouble() {
+  void test_pseudoGeneric_then() {
     String code = r'''
-import 'dart:math';
+import 'dart:async';
+String toString(int x) => x.toString();
 main() {
-  var foo = max(1, 2.0);
+  Future<int> bar = null;
+  var foo = bar.then(toString);
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
-    expect(declaration.initializer.staticType.name, 'num');
+
+    expect(declaration.initializer.staticType.toString(), "Future<String>");
     expect(declaration.initializer.propagatedType, isNull);
   }
 
-  void test_pseudoGeneric_max_doubleInt() {
+  void test_ternaryOperator_null_left() {
     String code = r'''
-import 'dart:math';
 main() {
-  var foo = max(1.0, 2);
+  var foo = (true) ? null : 3;
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
-    expect(declaration.initializer.staticType.name, 'num');
+    expect(declaration.initializer.staticType.name, 'int');
     expect(declaration.initializer.propagatedType, isNull);
   }
 
-  void test_pseudoGeneric_then() {
+  void test_ternaryOperator_null_right() {
     String code = r'''
-import 'dart:async';
-String toString(int x) => x.toString();
 main() {
-  Future<int> bar = null;
-  var foo = bar.then(toString);
+  var foo = (true) ? 3 : null;
 }
 ''';
     _resolveTestUnit(code);
 
     SimpleIdentifier identifier = _findIdentifier('foo');
     VariableDeclaration declaration =
         identifier.getAncestor((node) => node is VariableDeclaration);
-
-    expect(declaration.initializer.staticType.toString(), "Future<String>");
+    expect(declaration.initializer.staticType.name, 'int');
     expect(declaration.initializer.propagatedType, isNull);
   }
 }
 
 @reflectiveTest
 class StrongModeTypePropagationTest extends ResolverTestCase {
   @override
   void setUp() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
@@ skipping 478 matching lines @@
 import 'lib.dart';
 f(p) {
   if (p is A) {
     return p.v; // marker
   }
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
+  void fail_finalPropertyInducingVariable_classMember_instance_unprefixed() {
+    String code = r'''
+class A {
+  final v = 0;
+  m() {
+    v; // marker
+  }
+}''';
+    _assertTypeOfMarkedExpression(
+        code, typeProvider.dynamicType, typeProvider.intType);
+  }
+
   void fail_finalPropertyInducingVariable_classMember_static() {
     addNamedSource(
         "/lib.dart",
         r'''
 class A {
   static final V = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 f() {
@@ skipping 1274 matching lines @@
   Base x = null;
   if (x is Derived) {
     print(x.y); // GOOD
   }
   x = null;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
+  void test_objectAccessInference_disabled_for_library_prefix() {
+    String name = 'hashCode';
+    addNamedSource(
+        '/helper.dart',
+        '''
+library helper;
+dynamic get $name => 42;
+''');
+    String code = '''
+import 'helper.dart' as helper;
+main() {
+  helper.$name; // marker
+}''';
+
+    SimpleIdentifier id = _findMarkedIdentifier(code, "; // marker");
+    PrefixedIdentifier prefixedId = id.parent;
+    expect(id.staticType, typeProvider.dynamicType);
+    expect(prefixedId.staticType, typeProvider.dynamicType);
+  }
+
+  void test_objectAccessInference_disabled_for_local_getter() {
+    String name = 'hashCode';
+    String code = '''
+dynamic get $name => null;
+main() {
+  $name; // marker
+}''';
+
+    SimpleIdentifier getter = _findMarkedIdentifier(code, "; // marker");
+    expect(getter.staticType, typeProvider.dynamicType);
+  }
+
+  void test_objectAccessInference_enabled_for_cascades() {
+    String name = 'hashCode';
+    String code = '''
+main() {
+  dynamic obj;
+  obj..$name..$name; // marker
+}''';
+    PropertyAccess access = _findMarkedIdentifier(code, "; // marker").parent;
+    expect(access.staticType, typeProvider.dynamicType);
+    expect(access.realTarget.staticType, typeProvider.dynamicType);
+  }
+
+  void test_objectMethodInference_disabled_for_library_prefix() {
+    String name = 'toString';
+    addNamedSource(
+        '/helper.dart',
+        '''
+library helper;
+dynamic $name = (int x) => x + 42');
+''');
+    String code = '''
+import 'helper.dart' as helper;
+main() {
+  helper.$name(); // marker
+}''';
+    SimpleIdentifier methodName = _findMarkedIdentifier(code, "(); // marker");
+    MethodInvocation methodInvoke = methodName.parent;
+    expect(methodName.staticType, null, reason: 'library prefix has no type');
+    expect(methodInvoke.staticType, typeProvider.dynamicType);
+  }
+
+  void test_objectMethodInference_disabled_for_local_function() {
+    String name = 'toString';
+    String code = '''
+main() {
+  dynamic $name = () => null;
+  $name(); // marker
+}''';
+    SimpleIdentifier identifier = _findMarkedIdentifier(code, "$name = ");
+    expect(identifier.staticType, typeProvider.dynamicType);
+
+    SimpleIdentifier methodName = _findMarkedIdentifier(code, "(); // marker");
+    MethodInvocation methodInvoke = methodName.parent;
+    expect(methodName.staticType, typeProvider.dynamicType);
+    expect(methodInvoke.staticType, typeProvider.dynamicType);
+  }
+
+  void test_objectMethodInference_enabled_for_cascades() {
+    String name = 'toString';
+    String code = '''
+main() {
+  dynamic obj;
+  obj..$name()..$name(); // marker
+}''';
+    SimpleIdentifier methodName = _findMarkedIdentifier(code, "(); // marker");
+    MethodInvocation methodInvoke = methodName.parent;
+
+    expect(methodInvoke.staticType, typeProvider.dynamicType);
+    expect(methodInvoke.realTarget.staticType, typeProvider.dynamicType);
+  }
+
   void test_objectMethodOnDynamicExpression_doubleEquals() {
     // https://code.google.com/p/dart/issues/detail?id=20342
     //
     // This was not actually part of Issue 20342, since the spec specifies a
     // static type of [bool] for [==] comparison and the implementation
     // was already consistent with the spec there. But, it's another
     // [Object] method, so it's included here.
     _assertTypeOfMarkedExpression(
         r'''
 f1(x) {
@@ skipping 33 matching lines @@
     _assertTypeOfMarkedExpression(
         r'''
 f1(x) {
   var v = x.toString();
   return v; // marker
 }''',
         null,
         typeProvider.stringType);
   }
 
-  void test_objectMethodInference_disabled_for_local_function() {
-    String name = 'toString';
-    String code = '''
-main() {
-  dynamic $name = () => null;
-  $name(); // marker
-}''';
-    SimpleIdentifier identifier = _findMarkedIdentifier(code, "$name = ");
-    expect(identifier.staticType, typeProvider.dynamicType);
-
-    SimpleIdentifier methodName = _findMarkedIdentifier(code, "(); // marker");
-    MethodInvocation methodInvoke = methodName.parent;
-    expect(methodName.staticType, typeProvider.dynamicType);
-    expect(methodInvoke.staticType, typeProvider.dynamicType);
-  }
-
-  void test_objectMethodInference_disabled_for_library_prefix() {
-    String name = 'toString';
-    addNamedSource('/helper.dart', '''
-library helper;
-dynamic $name = (int x) => x + 42');
-''');
-    String code = '''
-import 'helper.dart' as helper;
-main() {
-  helper.$name(); // marker
-}''';
-    SimpleIdentifier methodName = _findMarkedIdentifier(code, "(); // marker");
-    MethodInvocation methodInvoke = methodName.parent;
-    expect(methodName.staticType, null, reason: 'library prefix has no type');
-    expect(methodInvoke.staticType, typeProvider.dynamicType);
-  }
-
-  void test_objectMethodInference_enabled_for_cascades() {
-    String name = 'toString';
-    String code = '''
-main() {
-  dynamic obj;
-  obj..$name()..$name(); // marker
-}''';
-    SimpleIdentifier methodName = _findMarkedIdentifier(code, "(); // marker");
-    MethodInvocation methodInvoke = methodName.parent;
-
-    expect(methodInvoke.staticType, typeProvider.dynamicType);
-    expect(methodInvoke.realTarget.staticType, typeProvider.dynamicType);
-  }
-
-
-  void test_objectAccessInference_disabled_for_local_getter() {
-    String name = 'hashCode';
-    String code = '''
-dynamic get $name => null;
-main() {
-  $name; // marker
-}''';
-
-    SimpleIdentifier getter = _findMarkedIdentifier(code, "; // marker");
-    expect(getter.staticType, typeProvider.dynamicType);
-  }
-
-  void test_objectAccessInference_disabled_for_library_prefix() {
-    String name = 'hashCode';
-    addNamedSource('/helper.dart', '''
-library helper;
-dynamic get $name => 42;
-''');
-    String code = '''
-import 'helper.dart' as helper;
-main() {
-  helper.$name; // marker
-}''';
-
-    SimpleIdentifier id = _findMarkedIdentifier(code, "; // marker");
-    PrefixedIdentifier prefixedId = id.parent;
-    expect(id.staticType, typeProvider.dynamicType);
-    expect(prefixedId.staticType, typeProvider.dynamicType);
-  }
-
-  void test_objectAccessInference_enabled_for_cascades() {
-    String name = 'hashCode';
-    String code = '''
-main() {
-  dynamic obj;
-  obj..$name..$name; // marker
-}''';
-    PropertyAccess access = _findMarkedIdentifier(code, "; // marker").parent;
-    expect(access.staticType, typeProvider.dynamicType);
-    expect(access.realTarget.staticType, typeProvider.dynamicType);
-  }
-
   void test_propagatedReturnType_localFunction() {
     String code = r'''
 main() {
   f() => 42;
   var v = f();
 }''';
     _assertPropagatedAssignedType(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
@@ skipping 817 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }
+
+/**
+ * Shared infrastructure for [StaticTypeAnalyzer2Test] and
+ * [StrongModeStaticTypeAnalyzer2Test].
+ */
+class _StaticTypeAnalyzer2TestShared extends ResolverTestCase {
+  String testCode;
+  Source testSource;
+  CompilationUnit testUnit;
+
+  SimpleIdentifier _findIdentifier(String search) {
+    SimpleIdentifier identifier = EngineTestCase.findNode(
+        testUnit, testCode, search, (node) => node is SimpleIdentifier);
+    return identifier;
+  }
+
+  void _resolveTestUnit(String code) {
+    testCode = code;
+    testSource = addSource(testCode);
+    LibraryElement library = resolve2(testSource);
+    assertNoErrors(testSource);
+    verify([testSource]);
+    testUnit = resolveCompilationUnit(testSource, library);
+  }
+}