[Kernel] Remove code from the old type propagation.

pkg/kernel/lib/ast.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.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 35 matching lines @@
 /// relatively few nodes.  Or use whichever is more convenient.
 ///
 /// The AST can also be mutated by direct field manipulation, but the user then
 /// has to update parent pointers manually.
 ///
 library kernel.ast;
 
 import 'visitor.dart';
 export 'visitor.dart';
 
-import 'type_propagation/type_propagation.dart';
-export 'type_propagation/type_propagation.dart';
-
 import 'canonical_name.dart' show CanonicalName;
 export 'canonical_name.dart' show CanonicalName;
 
 import 'transformations/flags.dart';
 import 'text/ast_to_text.dart';
 import 'type_algebra.dart';
 import 'type_environment.dart';
 
 /// Any type of node in the IR.
 abstract class Node {
@@ skipping 656 matching lines @@
     return transformerFlags & TransformerFlag.superCalls != 0;
   }
 }
 
 /// A field declaration.
 ///
 /// The implied getter and setter for the field are not represented explicitly,
 /// but can be made explicit if needed.
 class Field extends Member {
   DartType type; // Not null. Defaults to DynamicType.
-  InferredValue inferredValue; // May be null.
   int flags = 0;
   Expression initializer; // May be null.
 
   /// The uri of the source file this field was loaded from.
   String fileUri;
 
   Field(Name name,
       {this.type: const DynamicType(),
-      this.inferredValue,
       this.initializer,
       bool isFinal: false,
       bool isConst: false,
       bool isStatic: false,
       bool hasImplicitGetter,
       bool hasImplicitSetter,
       int transformerFlags: 0,
       this.fileUri,
       Reference reference})
       : super(name, reference) {
@@ skipping 72 matching lines @@
     if (value) throw 'Fields cannot be external';
   }
 
   accept(MemberVisitor v) => v.visitField(this);
 
   acceptReference(MemberReferenceVisitor v) => v.visitFieldReference(this);
 
   visitChildren(Visitor v) {
     visitList(annotations, v);
     type?.accept(v);
-    inferredValue?.accept(v);
     name?.accept(v);
     initializer?.accept(v);
   }
 
   transformChildren(Transformer v) {
     type = v.visitDartType(type);
     transformList(annotations, v, this);
     if (initializer != null) {
       initializer = initializer.accept(v);
       initializer?.parent = this;
@@ skipping 391 matching lines @@
   /// A Kernel function can represent a Dart function with a different async
   /// marker.
   ///
   /// For example, when async/await is translated away,
   /// a Dart async function might be represented by a Kernel sync function.
   AsyncMarker dartAsyncMarker;
   List<TypeParameter> typeParameters;
   int requiredParameterCount;
   List<VariableDeclaration> positionalParameters;
   List<VariableDeclaration> namedParameters;
-  InferredValue inferredReturnValue; // May be null.
   DartType returnType; // Not null.
   Statement body;
 
   FunctionNode(this.body,
       {List<TypeParameter> typeParameters,
       List<VariableDeclaration> positionalParameters,
       List<VariableDeclaration> namedParameters,
       int requiredParameterCount,
       this.returnType: const DynamicType(),
-      this.inferredReturnValue,
       this.asyncMarker: AsyncMarker.Sync,
       this.dartAsyncMarker})
       : this.positionalParameters =
             positionalParameters ?? <VariableDeclaration>[],
         this.requiredParameterCount =
             requiredParameterCount ?? positionalParameters?.length ?? 0,
         this.namedParameters = namedParameters ?? <VariableDeclaration>[],
         this.typeParameters = typeParameters ?? <TypeParameter>[] {
     assert(returnType != null);
     setParents(this.typeParameters, this);
@@ skipping 24 matching lines @@
         requiredParameterCount: requiredParameterCount);
   }
 
   accept(TreeVisitor v) => v.visitFunctionNode(this);
 
   visitChildren(Visitor v) {
     visitList(typeParameters, v);
     visitList(positionalParameters, v);
     visitList(namedParameters, v);
     returnType?.accept(v);
-    inferredReturnValue?.accept(v);
     body?.accept(v);
   }
 
   transformChildren(Transformer v) {
     transformList(typeParameters, v, this);
     transformList(positionalParameters, v, this);
     transformList(namedParameters, v, this);
     returnType = v.visitDartType(returnType);
     if (body != null) {
       body = body.accept(v);
@@ skipping 2144 matching lines @@
   int fileEqualsOffset = TreeNode.noOffset;
 
   /// For named parameters, this is the name of the parameter. No two named
   /// parameters (in the same parameter list) can have the same name.
   ///
   /// In all other cases, the name is cosmetic, may be empty or null,
   /// and is not necessarily unique.
   String name;
   int flags = 0;
   DartType type; // Not null, defaults to dynamic.
-  InferredValue inferredValue; // May be null.
 
   /// For locals, this is the initial value.
   /// For parameters, this is the default value.
   ///
   /// Should be null in other cases.
   Expression initializer; // May be null.
 
   VariableDeclaration(this.name,
       {this.initializer,
       this.type: const DynamicType(),
-      this.inferredValue,
       bool isFinal: false,
       bool isConst: false}) {
     assert(type != null);
     initializer?.parent = this;
     this.isFinal = isFinal;
     this.isConst = isConst;
   }
 
   /// Creates a synthetic variable with the given expression as initializer.
   VariableDeclaration.forValue(this.initializer,
@@ skipping 19 matching lines @@
 
   void set isConst(bool value) {
     flags = value ? (flags | FlagConst) : (flags & ~FlagConst);
   }
 
   accept(StatementVisitor v) => v.visitVariableDeclaration(this);
   accept1(StatementVisitor1 v, arg) => v.visitVariableDeclaration(this, arg);
 
   visitChildren(Visitor v) {
     type?.accept(v);
-    inferredValue?.accept(v);
     initializer?.accept(v);
   }
 
   transformChildren(Transformer v) {
     type = v.visitDartType(type);
     if (initializer != null) {
       initializer = initializer.accept(v);
       initializer?.parent = this;
     }
   }
@@ skipping 712 matching lines @@
 /// library has not been assigned a canonical name yet.
 ///
 /// Returns `null` if the library is `null`.
 CanonicalName getCanonicalNameOfLibrary(Library library) {
   if (library == null) return null;
   if (library.canonicalName == null) {
     throw '$library has no canonical name';
   }
   return library.canonicalName;
 }