Pay some naming debt.

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 19 matching lines @@
     ConstructorReferenceBuilder,
     DynamicTypeBuilder,
     EnumBuilder,
     FieldBuilder,
     FormalParameterBuilder,
     FunctionTypeAliasBuilder,
     KernelEnumBuilder,
     KernelFieldBuilder,
     KernelFormalParameterBuilder,
     KernelFunctionTypeAliasBuilder,
-    KernelInterfaceTypeBuilder,
     KernelInvalidTypeBuilder,
     KernelMixinApplicationBuilder,
     KernelNamedMixinApplicationBuilder,
+    KernelNamedTypeBuilder,
     KernelProcedureBuilder,
     KernelTypeBuilder,
     KernelTypeVariableBuilder,
     MemberBuilder,
     MetadataBuilder,
     MixedAccessor,
     NamedMixinApplicationBuilder,
     PrefixBuilder,
     ProcedureBuilder,
     TypeVariableBuilder;
 
 class KernelLibraryBuilder
     extends SourceLibraryBuilder<KernelTypeBuilder, Library> {
   final Library library;
 
   final List<Class> mixinApplicationClasses = <Class>[];
 
   final List<List> argumentsWithMissingDefaultValues = <List>[];
 
   KernelLibraryBuilder(Uri uri, Uri fileUri, Loader loader)
       : library = new Library(uri),
         super(loader, fileUri);
 
   Uri get uri => library.importUri;
 
-  KernelTypeBuilder addInterfaceType(String name,
+  KernelTypeBuilder addNamedType(String name,
       List<KernelTypeBuilder> arguments) {
-    KernelInterfaceTypeBuilder type =
-        new KernelInterfaceTypeBuilder(name, arguments);
+    KernelNamedTypeBuilder type =
+        new KernelNamedTypeBuilder(name, arguments);
     if (identical(name, "dynamic")) {
       // TODO(ahe): Make const.
       type.builder = new DynamicTypeBuilder(const DynamicType());
     } else {
       addType(type);
     }
     return type;
   }
 
   KernelTypeBuilder addMixinApplication(KernelTypeBuilder supertype,
       List<KernelTypeBuilder> mixins) {
     KernelTypeBuilder type =
         new KernelMixinApplicationBuilder(supertype, mixins);
     return addType(type);
   }
 
   KernelTypeBuilder addVoidType() {
-    return new KernelInterfaceTypeBuilder("void", null);
+    return new KernelNamedTypeBuilder("void", null);
   }
 
   ClassBuilder addClass(List<MetadataBuilder> metadata,
       int modifiers, String className,
       List<TypeVariableBuilder> typeVariables, KernelTypeBuilder supertype,
       List<KernelTypeBuilder> interfaces) {
     ClassBuilder cls = new SourceClassBuilder(metadata, modifiers, className,
         typeVariables, supertype, interfaces, classMembers, declarationTypes,
         this,
         new List<ConstructorReferenceBuilder>.from(constructorReferences));
     constructorReferences.clear();
     classMembers.forEach((String name, MemberBuilder builder) {
       while (builder != null) {
         builder.parent = cls;
         builder = builder.next;
       }
     });
-    // Nested scope began in `OutlineBuilder.beginClassDeclaration`.
-    endNestedScope();
+    // Nested declaration began in `OutlineBuilder.beginClassDeclaration`.
+    endNestedDeclaration();
     return addBuilder(className, cls);
   }
 
   NamedMixinApplicationBuilder addNamedMixinApplication(
       List<MetadataBuilder> metadata, String name,
       List<TypeVariableBuilder> typeVariables, int modifiers,
       KernelTypeBuilder mixinApplication, List<KernelTypeBuilder> interfaces) {
     NamedMixinApplicationBuilder builder =
         new KernelNamedMixinApplicationBuilder(metadata, name, typeVariables,
             modifiers, mixinApplication, interfaces, declarationTypes, this);
-    // Nested scope began in `OutlineBuilder.beginNamedMixinApplication`.
-    endNestedScope();
+    // Nested declaration began in `OutlineBuilder.beginNamedMixinApplication`.
+    endNestedDeclaration();
     return addBuilder(name, builder);
   }
 
   FieldBuilder addField(List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder type, String name) {
     return addBuilder(name,
         new KernelFieldBuilder(metadata, type, name, modifiers));
   }
 
   ProcedureBuilder addProcedure(List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals, AsyncMarker asyncModifier,
       ProcedureKind kind) {
-    // Nested scope began in `OutlineBuilder.beginMethod` or
+    // Nested declaration began in `OutlineBuilder.beginMethod` or
     // `OutlineBuilder.beginTopLevelMethod`.
-    endNestedScope().resolveTypes(typeVariables);
+    endNestedDeclaration().resolveTypes(typeVariables);
     return addBuilder(name,
         new KernelProcedureBuilder(metadata, modifiers, returnType, name,
             typeVariables, formals, asyncModifier, kind));
   }
 
   void addFactoryMethod(List<MetadataBuilder> metadata,
       ConstructorReferenceBuilder constructorName,
       List<FormalParameterBuilder> formals, AsyncMarker asyncModifier,
       ConstructorReferenceBuilder redirectionTarget) {
     String name = constructorName.name;
     assert(constructorName.suffix == null);
     addBuilder(name,
         new KernelProcedureBuilder(metadata, staticMask, null, name, null,
             formals, asyncModifier, ProcedureKind.Factory, redirectionTarget));
   }
 
   EnumBuilder addEnum(List<MetadataBuilder> metadata, String name,
       List<String> constants) {
     return addBuilder(name,
         new KernelEnumBuilder(metadata, name, constants, this));
   }
 
   FunctionTypeAliasBuilder addFunctionTypeAlias(List<MetadataBuilder> metadata,
       KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals) {
     FunctionTypeAliasBuilder typedef = new KernelFunctionTypeAliasBuilder(
         metadata, returnType, name, typeVariables, formals, declarationTypes,
         this);
-    // Nested scope began in `OutlineBuilder.beginFunctionTypeAlias`.
-    endNestedScope();
+    // Nested declaration began in `OutlineBuilder.beginFunctionTypeAlias`.
+    endNestedDeclaration();
     return addBuilder(name, typedef);
   }
 
   KernelFormalParameterBuilder addFormalParameter(
       List<MetadataBuilder> metadata, int modifiers,
       KernelTypeBuilder type, String name, bool hasThis) {
     return new KernelFormalParameterBuilder(
         metadata, modifiers, type, name, hasThis);
   }
 
@@ skipping 95 matching lines @@
           }
           expression.value =
               defaultArgumentFrom(names[expression.name].initializer)
               ..parent = expression;
         }
       }
     }
     return argumentsWithMissingDefaultValues.length;
   }
 }