Add debug names to scopes.

pkg/front_end/lib/src/fasta/scope.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.scope;
 
 import 'builder/builder.dart' show Builder, TypeVariableBuilder;
 
 import 'fasta_codes.dart'
     show
@@ skipping 10 matching lines @@
   /// Names declared in this scope.
   Map<String, Builder> local;
 
   /// Setters declared in this scope.
   Map<String, Builder> setters;
 
   /// The scope that this scope is nested within, or `null` if this is the top
   /// level scope.
   Scope parent;
 
-  MutableScope(this.local, this.setters, this.parent);
+  final String debugName;
+
+  MutableScope(this.local, this.setters, this.parent, this.debugName) {
+    assert(debugName != null);
+  }
+
+  String toString() => "Scope($debugName, ${local.keys})";
 }
 
 class Scope extends MutableScope {
   /// Indicates whether an attempt to declare new names in this scope should
   /// succeed.
   final bool isModifiable;
 
   Map<String, Builder> labels;
 
   Map<String, Builder> forwardDeclaredLabels;
 
   Map<String, int> usedNames;
 
   Scope(Map<String, Builder> local, Map<String, Builder> setters, Scope parent,
-      {this.isModifiable: true})
-      : super(local, setters = setters ?? const <String, Builder>{}, parent);
+      String debugName, {this.isModifiable: true})
+      : super(local, setters = setters ?? const <String, Builder>{}, parent,
+            debugName);
 
   Scope.top({bool isModifiable: false})
-      : this(<String, Builder>{}, <String, Builder>{}, null,
+      : this(<String, Builder>{}, <String, Builder>{}, null, "top",
             isModifiable: isModifiable);
 
   Scope.immutable()
       : this(const <String, Builder>{}, const <String, Builder>{}, null,
+            "immutable",
             isModifiable: false);
 
-  Scope.nested(Scope parent, {bool isModifiable: true})
-      : this(<String, Builder>{}, null, parent, isModifiable: isModifiable);
+  Scope.nested(Scope parent, String debugName, {bool isModifiable: true})
+      : this(<String, Builder>{}, null, parent, debugName,
+            isModifiable: isModifiable);
 
   /// Don't use this. Use [becomePartOf] instead.
   void set local(_) => unsupported("local=", -1, null);
 
   /// Don't use this. Use [becomePartOf] instead.
   void set setters(_) => unsupported("setters=", -1, null);
 
   /// Don't use this. Use [becomePartOf] instead.
   void set parent(_) => unsupported("parent=", -1, null);
 
   /// This scope becomes equivalent to [scope]. This is used for parts to
   /// become part of their library's scope.
   void becomePartOf(Scope scope) {
     assert(parent.parent == null);
     assert(scope.parent.parent == null);
     super.local = scope.local;
     super.setters = scope.setters;
     super.parent = scope.parent;
   }
 
-  Scope createNestedScope({bool isModifiable: true}) {
-    return new Scope.nested(this, isModifiable: isModifiable);
+  Scope createNestedScope(String debugName, {bool isModifiable: true}) {
+    return new Scope.nested(this, debugName, isModifiable: isModifiable);
   }
 
   Scope withTypeVariables(List<TypeVariableBuilder> typeVariables) {
     if (typeVariables == null) return this;
-    Scope newScope = new Scope.nested(this, isModifiable: false);
+    Scope newScope =
+        new Scope.nested(this, "type variables", isModifiable: false);
     for (TypeVariableBuilder t in typeVariables) {
       newScope.local[t.name] = t;
     }
     return newScope;
   }
 
   /// Create a special scope for use by labeled staments. This scope doesn't
   /// introduce a new scope for local variables, only for labels. This deals
   /// with corner cases like this:
   ///
   ///     L: var x;
   ///     x = 42;
   ///     print("The answer is $x.");
   Scope createNestedLabelScope() {
-    return new Scope(local, setters, parent, isModifiable: true);
+    return new Scope(local, setters, parent, "label", isModifiable: true);
   }
 
   void recordUse(String name, int charOffset, Uri fileUri) {
     if (isModifiable) {
       usedNames ??= <String, int>{};
       usedNames.putIfAbsent(name, () => charOffset);
     }
   }
 
   Builder lookupIn(String name, int charOffset, Uri fileUri,
@@ skipping 210 matching lines @@
 
   Message get message => templateAccessError.withArguments(name);
 }
 
 class AmbiguousBuilder extends ProblemBuilder {
   AmbiguousBuilder(String name, Builder builder, int charOffset, Uri fileUri)
       : super(name, builder, charOffset, fileUri);
 
   Message get message => templateDuplicatedName.withArguments(name);
 }