Don't perform final fields and top-level variables type propagation.

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

 // Copyright (c) 2015, 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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 7715 matching lines @@
         serializeClassText('class C { static var v = 0; }').fields[0];
     checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'dart:core', 'int');
   }
 
   test_field_inferred_type_static_implicit_uninitialized() {
     UnlinkedVariable v =
         serializeClassText('class C { static var v; }').fields[0];
     expect(v.inferredTypeSlot, 0);
   }
 
-  test_field_propagated_type_final_immediate() {
-    UnlinkedVariable v =
-        serializeClassText('class C { final v = 0; }').fields[0];
-    checkLinkedTypeSlot(v.propagatedTypeSlot, 'dart:core', 'dart:core', 'int');
-  }
-
   test_field_static() {
     UnlinkedVariable variable =
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
     expect(variable.initializer, isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
     expect(unlinkedUnits[0].publicNamespace.names[0].members, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].members[0].name, 'i');
     expect(unlinkedUnits[0].publicNamespace.names[0].members[0].kind,
@@ skipping 28 matching lines @@
     if (!checkAstDerivedData) {
       // The element model doesn't contain the initializer expressions needed
       // for type inference.  TODO(paulberry): fix.
       return;
     }
     UnlinkedVariable variable =
         serializeClassText('class C { var x = 0; }').fields[0];
     expect(variable.initializer.bodyExpr, isNotNull);
   }
 
-  test_fully_linked_references_follow_other_references() {

[Paul Berry, 2016/08/29 20:52:16]

Rather than delete this test we should rewrite it in a way that doesn't make use
of propagated types.

Let me know if you'd rather I do this in a follow up CL.

[scheglov, 2016/08/29 22:01:47]

I restored these 3 tests and changed to use 'inferredTypeSlot' instead.

-    if (skipFullyLinkedData) {
-      return;
-    }
-    serializeLibraryText('final x = 0; String y;');
-    checkLinkedTypeSlot(unlinkedUnits[0].variables[0].propagatedTypeSlot,
-        'dart:core', 'dart:core', 'int');
-    checkTypeRef(
-        unlinkedUnits[0].variables[1].type, 'dart:core', 'dart:core', 'String');
-    // Even though the definition of y follows the definition of x, the linked
-    // type reference for x should use a higher numbered reference than the
-    // unlinked type reference for y.
-    EntityRef propagatedType =
-        getTypeRefForSlot(unlinkedUnits[0].variables[0].propagatedTypeSlot);
-    expect(unlinkedUnits[0].variables[1].type.reference,
-        lessThan(propagatedType.reference));
-  }
-
   test_function_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 f() {}''';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.documentationComment, isNotNull);
     checkDocumentationComment(executable.documentationComment, text);
@@ skipping 886 matching lines @@
     String text = '''
 int foo;
 class Test {}
 
 int bar;'''
         .replaceAll('\r\n', '\n');
     serializeLibraryText(text);
     expect(unlinkedUnits[0].lineStarts, [0, 9, 23, 24]);
   }
 
-  test_linked_reference_reuse() {

[Paul Berry, 2016/08/29 20:52:16]

Ditto.

-    if (skipFullyLinkedData) {
-      return;
-    }
-    // When the reference for a linked type is the same as an explicitly
-    // referenced type, the explicit reference should be re-used.
-    addNamedSource('/a.dart', 'class C {}');
-    addNamedSource('/b.dart', 'import "a.dart"; C f() => null;');
-    serializeLibraryText(
-        'import "a.dart"; import "b.dart"; C c1; final c2 = f();');
-    int explicitReference = findVariable('c1').type.reference;
-    expect(getTypeRefForSlot(findVariable('c2').propagatedTypeSlot).reference,
-        explicitReference);
-  }
-
-  test_linked_type_dependency_reuse() {

[Paul Berry, 2016/08/29 20:52:16]

Ditto.

-    if (skipFullyLinkedData) {
-      return;
-    }
-    // When the dependency for a linked type is the same as an explicit
-    // dependency, the explicit dependency should be re-used.
-    addNamedSource('/a.dart', 'class C {} class D {}');
-    addNamedSource('/b.dart', 'import "a.dart"; D f() => null;');
-    serializeLibraryText(
-        'import "a.dart"; import "b.dart"; C c; final d = f();');
-    int cReference = findVariable('c').type.reference;
-    int explicitDependency = linked.units[0].references[cReference].dependency;
-    int dReference =
-        getTypeRefForSlot(findVariable('d').propagatedTypeSlot).reference;
-    expect(
-        linked.units[0].references[dReference].dependency, explicitDependency);
-  }
-
   test_local_names_take_precedence_over_imported_names() {
     addNamedSource('/a.dart', 'class C {} class D {}');
     serializeLibraryText('''
 import 'a.dart';
 class C {}
 C c;
 D d;''');
     checkTypeRef(findVariable('c').type, null, null, 'C');
     checkTypeRef(findVariable('d').type, absUri('/a.dart'), 'a.dart', 'D');
   }
@@ skipping 828 matching lines @@
 }
 ''').localVariables[0];
     EntityRef inferredType =
         getTypeRefForSlot(variable.initializer.inferredReturnTypeSlot);
     checkLinkedTypeRef(
         inferredType.syntheticReturnType, 'dart:core', 'dart:core', 'int');
     checkParamTypeRef(inferredType.syntheticParams[0].type, 2);
     checkParamTypeRef(inferredType.syntheticParams[1].type, 1);
   }
 
-  test_syntheticFunctionType_noArguments() {
-    if (skipFullyLinkedData) {
-      return;
-    }
-    UnlinkedVariable variable = serializeVariableText('''
-final v = f() ? () => 0 : () => 1;
-bool f() => true;
-''');
-    EntityRef propagatedType = getTypeRefForSlot(variable.propagatedTypeSlot);
-    checkLinkedTypeRef(
-        propagatedType.syntheticReturnType, 'dart:core', 'dart:core', 'int');
-    expect(propagatedType.syntheticParams, isEmpty);
-  }
-
-  test_syntheticFunctionType_withArguments() {
-    if (skipFullyLinkedData) {
-      return;
-    }
-    UnlinkedVariable variable = serializeVariableText('''
-final v = f() ? (int x, String y) => 0 : (int x, String y) => 1;
-bool f() => true;
-''');
-    EntityRef propagatedType = getTypeRefForSlot(variable.propagatedTypeSlot);
-    checkTypeRef(
-        propagatedType.syntheticReturnType, 'dart:core', 'dart:core', 'int');
-    expect(propagatedType.syntheticParams, hasLength(2));
-    checkTypeRef(propagatedType.syntheticParams[0].type, 'dart:core',
-        'dart:core', 'int');
-    checkTypeRef(propagatedType.syntheticParams[1].type, 'dart:core',
-        'dart:core', 'String');
-  }
-
   test_type_arguments_explicit() {
     EntityRef typeRef = serializeTypeText('List<int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         numTypeParameters: 1, numTypeArguments: 1);
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic() {
     EntityRef typeRef = serializeTypeText('List<dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
@@ skipping 691 matching lines @@
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     expect(variable.isStatic, isFalse);
   }
 
   test_variable_private() {
     serializeVariableText('int _i;', variableName: '_i');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
-  test_variable_propagated_type_final_immediate() {
-    UnlinkedVariable v = serializeVariableText('final v = 0;');
-    checkLinkedTypeSlot(v.propagatedTypeSlot, 'dart:core', 'dart:core', 'int');
-  }
-
-  test_variable_propagated_type_new_reference() {
-    if (skipFullyLinkedData) {
-      return;
-    }
-    UnlinkedVariable v = serializeVariableText('final v = 0;');
-    // Since the propagated type of `v` is `int`, and there are no references
-    // to `int` elsewhere in the source file, a new linked reference should
-    // have been created for it, with no associated unlinked reference.
-    expect(v.propagatedTypeSlot, isNot(0));
-    EntityRef type = getTypeRefForSlot(v.propagatedTypeSlot);
-    expect(type, isNotNull);
-    expect(type.reference,
-        greaterThanOrEqualTo(unlinkedUnits[0].references.length));
-  }
-
-  test_variable_propagated_type_omit_dynamic() {
-    if (skipFullyLinkedData) {
-      return;
-    }
-    UnlinkedVariable v = serializeVariableText('final v = <int, dynamic>{};');
-    EntityRef type = getTypeRefForSlot(v.propagatedTypeSlot);
-    checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
-        numTypeParameters: 2, numTypeArguments: 2);
-    checkLinkedTypeRef(type.typeArguments[0], 'dart:core', 'dart:core', 'int');
-    checkLinkedDynamicTypeRef(type.typeArguments[1]);
-  }
-
-  test_variable_propagatedTypeSlot_const() {
-    // Const variables are propagable so they have a nonzero
-    // propagatedTypeSlot.
-    UnlinkedVariable variable = serializeVariableText('const v = 0;');
-    expect(variable.propagatedTypeSlot, isNot(0));
-  }
-
-  test_variable_propagatedTypeSlot_final() {
-    // Final variables are propagable so they have a nonzero
-    // propagatedTypeSlot.
-    UnlinkedVariable variable = serializeVariableText('final v = 0;');
-    expect(variable.propagatedTypeSlot, isNot(0));
-  }
-
-  test_variable_propagatedTypeSlot_non_propagable() {
-    // Non-final non-const variables aren't propagable so they don't have a
-    // propagatedTypeSlot.
-    UnlinkedVariable variable = serializeVariableText('var v;');
-    expect(variable.propagatedTypeSlot, 0);
-  }
-
   test_variable_static() {
     UnlinkedVariable variable =
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
   }
 
   test_variable_type() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
@@ skipping 177 matching lines @@
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
 }