Add debug names to scopes.

pkg/front_end/lib/src/fasta/kernel/body_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.body_builder;
 
 import 'package:kernel/ast.dart'
     hide InvalidExpression, InvalidInitializer, InvalidStatement;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
@@ skipping 1712 matching lines @@
     // TODO(ahe): Unused code fasta.messageNonInstanceTypeVariableUse.
   }
 
   @override
   void beginFunctionType(Token beginToken) {
     debugEvent("beginFunctionType");
     enterFunctionTypeScope();
   }
 
   void enterFunctionTypeScope() {
+    debugEvent("enterFunctionTypeScope");
     List typeVariables = pop();
-    enterLocalScope(scope.createNestedScope(isModifiable: false));
+    enterLocalScope(null,
+        scope.createNestedScope("function-type scope", isModifiable: false));
     push(typeVariables ?? NullValue.TypeVariables);
     if (typeVariables != null) {
       ScopeBuilder scopeBuilder = new ScopeBuilder(scope);
       for (KernelTypeVariableBuilder builder in typeVariables) {
         String name = builder.name;
         KernelTypeVariableBuilder existing = scopeBuilder[name];
         if (existing == null) {
           scopeBuilder.addMember(name, builder);
         } else {
           deprecated_addCompileTimeError(
@@ skipping 193 matching lines @@
       count--;
     }
     FormalParameters formals = new FormalParameters(
         popList(count) ?? <VariableDeclaration>[],
         optional,
         beginToken.charOffset);
     constantExpressionRequired = pop();
     push(formals);
     if ((inCatchClause || functionNestingLevel != 0) &&
         kind != MemberKind.GeneralizedFunctionType) {
-      enterLocalScope(formals.computeFormalParameterScope(
-          scope, member ?? classBuilder ?? library, this));
+      enterLocalScope(
+          null,
+          formals.computeFormalParameterScope(
+              scope, member ?? classBuilder ?? library, this));
     }
   }
 
   @override
   void beginCatchClause(Token token) {
     debugEvent("beginCatchClause");
     inCatchClause = true;
   }
 
   @override
@@ skipping 491 matching lines @@
     debugEvent("beginLocalFunctionDeclaration");
     enterFunction();
   }
 
   @override
   void beginNamedFunctionExpression(Token token) {
     debugEvent("beginNamedFunctionExpression");
     List typeVariables = pop();
     // Create an additional scope in which the named function expression is
     // declared.
-    enterLocalScope();
+    enterLocalScope("named function");
     push(typeVariables ?? NullValue.TypeVariables);
     enterFunction();
   }
 
   @override
   void beginFunctionExpression(Token token) {
     debugEvent("beginFunctionExpression");
     enterFunction();
   }
 
@@ skipping 101 matching lines @@
       ..fileOffset = doKeyword.charOffset;
     if (breakTarget.hasUsers) {
       result = new KernelLabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
   @override
   void beginForInExpression(Token token) {
-    enterLocalScope(scope.parent);
+    enterLocalScope(null, scope.parent);
   }
 
   @override
   void endForInExpression(Token token) {
     debugEvent("ForInExpression");
     Expression expression = popForValue();
     exitLocalScope();
     push(expression ?? NullValue.Expression);
   }
 
@@ skipping 57 matching lines @@
   void handleLabel(Token token) {
     debugEvent("Label");
     Identifier identifier = pop();
     push(new Label(identifier.name));
   }
 
   @override
   void beginLabeledStatement(Token token, int labelCount) {
     debugEvent("beginLabeledStatement");
     List<Label> labels = popList(labelCount);
-    enterLocalScope(scope.createNestedLabelScope());
+    enterLocalScope(null, scope.createNestedLabelScope());
     LabelTarget target =
         new LabelTarget(member, functionNestingLevel, token.charOffset);
     for (Label label in labels) {
       scope.declareLabel(label.name, target);
     }
     push(target);
   }
 
   @override
   void endLabeledStatement(int labelCount) {
@@ skipping 121 matching lines @@
   @override
   void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
     debugEvent("YieldStatement");
     push(new KernelYieldStatement(popForValue(), isYieldStar: starToken != null)
       ..fileOffset = yieldToken.charOffset);
   }
 
   @override
   void beginSwitchBlock(Token token) {
     debugEvent("beginSwitchBlock");
-    enterLocalScope();
+    enterLocalScope("switch block");
     enterSwitchScope();
     enterBreakTarget(token.charOffset);
   }
 
   @override
   void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) {
     debugEvent("beginSwitchCase");
     List labelsAndExpressions = popList(labelCount + expressionCount);
     List<Label> labels = <Label>[];
     List<Expression> expressions = <Expression>[];
@@ skipping 10 matching lines @@
     for (Label label in labels) {
       if (scope.hasLocalLabel(label.name)) {
         // TODO(ahe): Should validate this is a goto target and not duplicated.
         scope.claimLabel(label.name);
       } else {
         scope.declareLabel(label.name, createGotoTarget(firstToken.charOffset));
       }
     }
     push(expressions);
     push(labels);
-    enterLocalScope();
+    enterLocalScope("switch case");
   }
 
   @override
   void endSwitchCase(int labelCount, int expressionCount, Token defaultKeyword,
       int statementCount, Token firstToken, Token endToken) {
     debugEvent("SwitchCase");
     // We always create a block here so that we later know that there's always
     // one synthetic block when we finish compiling the switch statement and
     // check this switch case to see if it falls through to the next case.
     Block block = popBlock(statementCount, firstToken);
@@ skipping 912 matching lines @@
     if (optional != null) {
       for (VariableDeclaration parameter in optional.formals) {
         if (local[parameter.name] != null) {
           helper.deprecated_addCompileTimeError(
               parameter.fileOffset, "Duplicated name.");
         }
         local[parameter.name] =
             new KernelVariableBuilder(parameter, builder, builder.fileUri);
       }
     }
-    return new Scope(local, null, parent, isModifiable: false);
+    return new Scope(local, null, parent, "formals", isModifiable: false);
   }
 }
 
 /// Returns a block like this:
 ///
 ///     {
 ///       statement;
 ///       body;
 ///     }
 ///
@@ skipping 40 matching lines @@
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return unhandled(asyncToken.lexeme, "asyncMarkerFromTokens",
         asyncToken.charOffset, null);
   }
 }