Compute bounds of type variables.

pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.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.
 
 library fasta.kernel_library_builder;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show
     CloneVisitor;
@@ skipping 47 matching lines @@
     TypeVariableBuilder;
 
 class KernelLibraryBuilder
     extends SourceLibraryBuilder<KernelTypeBuilder, Library> {
   final Library library;
 
   final List<Class> mixinApplicationClasses = <Class>[];
 
   final List<List> argumentsWithMissingDefaultValues = <List>[];
 
+  final List<KernelTypeVariableBuilder> boundlessTypeVariables =
+      <KernelTypeVariableBuilder>[];
+
   KernelLibraryBuilder(Uri uri, Uri fileUri, Loader loader)
       : library = new Library(uri, fileUri: relativizeUri(fileUri)),
         super(loader, fileUri);
 
   Uri get uri => library.importUri;
 
   KernelTypeBuilder addNamedType(String name,
       List<KernelTypeBuilder> arguments, int charOffset) {
     KernelNamedTypeBuilder type =
         new KernelNamedTypeBuilder(name, arguments, charOffset, fileUri);
@@ skipping 116 matching lines @@
 
   KernelFormalParameterBuilder addFormalParameter(
       List<MetadataBuilder> metadata, int modifiers,
       KernelTypeBuilder type, String name, bool hasThis, int charOffset) {
     return new KernelFormalParameterBuilder(
         metadata, modifiers, type, name, hasThis, this, charOffset);
   }
 
   KernelTypeVariableBuilder addTypeVariable(String name,
       KernelTypeBuilder bound, int charOffset) {
-    return new KernelTypeVariableBuilder(name, this, charOffset, bound);
+    var builder = new KernelTypeVariableBuilder(name, this, charOffset, bound);
+    boundlessTypeVariables.add(builder);
+    return builder;
   }
 
   void buildBuilder(Builder builder) {
     if (builder is SourceClassBuilder) {
       Class cls = builder.build(this);
       library.addClass(cls);
       Class superclass = cls.superclass;
       if (superclass != null && superclass.isMixinApplication) {
         List<Class> mixinApplications = <Class>[];
         mixinApplicationClasses.add(cls);
@@ skipping 89 matching lines @@
     return argumentsWithMissingDefaultValues.length;
   }
 
   List<TypeVariableBuilder> copyTypeVariables(
       List<TypeVariableBuilder> original) {
     List<TypeVariableBuilder> copy = <TypeVariableBuilder>[];
     for (KernelTypeVariableBuilder variable in original) {
       var newVariable = new KernelTypeVariableBuilder(
           variable.name, this, variable.charOffset);
       copy.add(newVariable);
+      boundlessTypeVariables.add(newVariable);
     }
     Map<TypeVariableBuilder, TypeBuilder> substitution =
         <TypeVariableBuilder, TypeBuilder>{};
     int i = 0;
     for (KernelTypeVariableBuilder variable in original) {
       substitution[variable] = copy[i++].asTypeBuilder();
     }
     i = 0;
     for (KernelTypeVariableBuilder variable in original) {
       copy[i++].bound = variable.bound?.subst(substitution);
     }
     return copy;
   }
+
+  int finishTypeVariables(ClassBuilder object) {
+    int count = boundlessTypeVariables.length;
+    for (KernelTypeVariableBuilder builder in boundlessTypeVariables) {
+      builder.finish(object);
+    }
+    boundlessTypeVariables.clear();
+    return count;
+  }
+
+  @override
+  void includePart(KernelLibraryBuilder part) {
+    super.includePart(part);
+    boundlessTypeVariables.addAll(part.boundlessTypeVariables);
+    mixinApplicationClasses.addAll(part.mixinApplicationClasses);
+  }
 }
 
 bool isConstructorName(String name, String className) {
   if (name.startsWith(className)) {
     if (name.length == className.length) return true;
     if (name.startsWith(".", className.length)) return true;
   }
   return false;
 }