Fail inference when an instance field is referenced.

pkg/analyzer/test/src/summary/linker_test.dart

 // Copyright (c) 2016, 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/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/link.dart';
 import 'package:test/test.dart';
@@ skipping 330 matching lines @@
 class E {}
 ''',
         path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 var y = C.x;
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     expect(_getVariable(library.getContainedName('y')).inferredType.toString(),
-        '(D) → E');
+        '(D) → dynamic');

[Brian Wilkerson, 2017/03/17 22:39:42]

Are these tests worth keeping? If we're not doing any inference then we're only
checking for standard resolution, which we have presumably tested elsewhere.

[scheglov, 2017/03/18 01:54:52]

It is partially a question of taste.
Tests in this file (linker_test.dart) are closer to unit tests.
Parsing, summarizing and linking is finely grained orchestrated by the test
itself, there is special test specific machinery for this.

Tests in the other file (top_level_inference_test.dart) are shifted closer to
functional tests.
We use AnalysisDriver to parse files, create unlinked summaries, linking and
resynthesizing.
No additional machinery in the test itself, but more happens under hood.

I incline to review these tests and move them to top_level_inference_test at
some point.



As for other tests that I touched in this CL in general, that's a fair question.
Many of them test features that are now not allowed. Unfortunately most of these
tests are bulky and test many things at once. So, careful surgery is required to
severe parts that we still want to test from the parts that are not necessary
anymore. I plan to review these tests and make these changes before landing this
CL.

   }
 
   void test_inferredType_instanceField_conditional_genericFunctions() {
     createLinker('''
 class C {
   final f = true ? <T>(T t) => 0 : <T>(T t) => 1;
 }
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     library.libraryCycleForLink.ensureLinked();
@@ skipping 120 matching lines @@
     var bundle = createPackageBundle(
         '''
 class C {
   var f = 0; // Inferred type: int
 }
 ''',
         path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
-var x = new C().f; // Inferred type: int
+var x = new C().f; // Inferred type: dynamic
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     expect(_getVariable(library.getContainedName('x')).inferredType.toString(),
-        'int');
+        'dynamic');
   }
 
   void test_inferredTypeFromOutsideBuildUnit_instanceField_toInstanceField() {
     var bundle = createPackageBundle(
         '''
 class C {
   var f = 0; // Inferred type: int
 }
 ''',
         path: '/a.dart');
     addBundle('/a.ds', bundle);
     createLinker('''
 import 'a.dart';
 class D {
   var g = new C().f; // Inferred type: int
 }
 ''');
     LibraryElementForLink library = linker.getLibrary(linkerInputs.testDartUri);
     ClassElementForLink_Class classD = library.getContainedName('D');
-    expect(classD.fields[0].inferredType.toString(), 'int');
+    expect(classD.fields[0].inferredType.toString(), 'dynamic');
   }
 
   void test_inferredTypeFromOutsideBuildUnit_methodParamType_viaGeneric() {
     var bundle = createPackageBundle(
         '''
 class B {
   T f<T>(T t) => t;
 }
 class C extends B {
   f<T>(t) => t; // Inferred param type: T
@@ skipping 438 matching lines @@
    */
   EntityRef _lookupInferredType(LinkedUnit unit, int slot) {
     for (EntityRef ref in unit.types) {
       if (ref.slot == slot) {
         return ref;
       }
     }
     return null;
   }
 }