Add names to nested declaration to ease debugging.

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:front_end/src/scanner/token.dart' show Token;
 
 import 'package:kernel/ast.dart';
 
@@ skipping 89 matching lines @@
 
   void addClass(
       List<MetadataBuilder> metadata,
       int modifiers,
       String className,
       List<TypeVariableBuilder> typeVariables,
       KernelTypeBuilder supertype,
       List<KernelTypeBuilder> interfaces,
       int charOffset) {
     // Nested declaration began in `OutlineBuilder.beginClassDeclaration`.
-    var declaration = endNestedDeclaration()..resolveTypes(typeVariables, this);
+    var declaration = endNestedDeclaration(className)
+      ..resolveTypes(typeVariables, this);
     assert(declaration.parent == libraryDeclaration);
     Map<String, MemberBuilder> members = declaration.members;
     Map<String, MemberBuilder> constructors = declaration.constructors;
     Map<String, MemberBuilder> setters = declaration.setters;
 
     Scope classScope = new Scope(
         members, setters, scope.withTypeVariables(typeVariables),
         isModifiable: false);
 
     // When looking up a constructor, we don't consider type variables or the
@@ skipping 324 matching lines @@
 
   void addNamedMixinApplication(
       List<MetadataBuilder> metadata,
       String name,
       List<TypeVariableBuilder> typeVariables,
       int modifiers,
       KernelTypeBuilder mixinApplication,
       List<KernelTypeBuilder> interfaces,
       int charOffset) {
     // Nested declaration began in `OutlineBuilder.beginNamedMixinApplication`.
-    endNestedDeclaration().resolveTypes(typeVariables, this);
+    endNestedDeclaration(name).resolveTypes(typeVariables, this);
     KernelNamedTypeBuilder supertype = applyMixins(mixinApplication,
         metadata: metadata,
         name: name,
         typeVariables: typeVariables,
         modifiers: modifiers,
         interfaces: interfaces,
         charOffset: charOffset);
     checkTypeVariables(typeVariables, supertype.builder);
   }
 
@@ skipping 45 matching lines @@
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
       ProcedureKind kind,
       int charOffset,
       int charOpenParenOffset,
       int charEndOffset,
       String nativeMethodName,
       {bool isTopLevel}) {
     // Nested declaration began in `OutlineBuilder.beginMethod` or
     // `OutlineBuilder.beginTopLevelMethod`.
-    endNestedDeclaration().resolveTypes(typeVariables, this);
+    endNestedDeclaration(name).resolveTypes(typeVariables, this);
     ProcedureBuilder procedure;
     String constructorName =
         isTopLevel ? null : computeAndValidateConstructorName(name, charOffset);
     if (constructorName != null) {
       name = constructorName;
       procedure = new KernelConstructorBuilder(
           metadata,
           modifiers & ~abstractMask,
           returnType,
           name,
@@ skipping 33 matching lines @@
       List<FormalParameterBuilder> formals,
       ConstructorReferenceBuilder redirectionTarget,
       int charOffset,
       int charOpenParenOffset,
       int charEndOffset,
       String nativeMethodName) {
     KernelTypeBuilder returnType = addNamedType(
         currentDeclaration.parent.name, <KernelTypeBuilder>[], charOffset);
     // Nested declaration began in `OutlineBuilder.beginFactoryMethod`.
     DeclarationBuilder<KernelTypeBuilder> factoryDeclaration =
-        endNestedDeclaration();
+        endNestedDeclaration("#factory_method");
     String name = constructorNameReference.name;
     String constructorName =
         computeAndValidateConstructorName(name, charOffset);
     if (constructorName != null) {
       name = constructorName;
     }
     assert(constructorNameReference.suffix == null);
     KernelProcedureBuilder procedure = new KernelProcedureBuilder(
         metadata,
         staticMask | modifiers,
@@ skipping 28 matching lines @@
       List<MetadataBuilder> metadata,
       KernelTypeBuilder returnType,
       String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
       int charOffset) {
     FunctionTypeAliasBuilder typedef = new KernelFunctionTypeAliasBuilder(
         metadata, returnType, name, typeVariables, formals, this, charOffset);
     checkTypeVariables(typeVariables, typedef);
     // Nested declaration began in `OutlineBuilder.beginFunctionTypeAlias`.
-    endNestedDeclaration().resolveTypes(typeVariables, this);
+    endNestedDeclaration("#typedef").resolveTypes(typeVariables, this);
     addBuilder(name, typedef, charOffset);
   }
 
   KernelFunctionTypeBuilder addFunctionType(
       KernelTypeBuilder returnType,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
       int charOffset) {
     var builder = new KernelFunctionTypeBuilder(
         charOffset, fileUri, returnType, typeVariables, formals);
@@ skipping 220 matching lines @@
           mixinApplicationClasses.putIfAbsent(name, () => builder);
       if (existing != builder) {
         part.scope.local.remove(name);
       }
     });
     super.includePart(part);
     nativeMethods.addAll(part.nativeMethods);
     boundlessTypeVariables.addAll(part.boundlessTypeVariables);
   }
 }