Add ScopeInfo class for variable information that doesn't actually involve closures.

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 818 matching lines @@
    * updated in the [localsHandler]. This function creates such an element and
    * stores it in the [returnLocal] field.
    */
   void setupStateForInlining(
       MethodElement function, List<HInstruction> compiledArguments,
       {ResolutionInterfaceType instanceType}) {
     ResolvedAst resolvedAst = function.resolvedAst;
     assert(resolvedAst != null);
     localsHandler = new LocalsHandler(this, function, function.memberContext,
         function.contextClass, instanceType, nativeData, interceptorData);
-    localsHandler.closureData =
-        closureDataLookup.getClosureRepresentationInfo(function);
+    localsHandler.scopeInfo = closureDataLookup.getScopeInfo(function);
     returnLocal =
         new SyntheticLocal("result", function, function.memberContext);
     localsHandler.updateLocal(returnLocal, graph.addConstantNull(closedWorld));
 
     inTryStatement = false; // TODO(lry): why? Document.
 
     int argumentIndex = 0;
     if (function.isInstanceMember) {
-      localsHandler.updateLocal(localsHandler.closureData.thisLocal,
+      localsHandler.updateLocal(localsHandler.scopeInfo.thisLocal,
           compiledArguments[argumentIndex++]);
     }
 
     FunctionSignature signature = function.functionSignature;
     signature.orderedForEachParameter((_parameter) {
       ParameterElement parameter = _parameter;
       HInstruction argument = compiledArguments[argumentIndex++];
       localsHandler.updateLocal(parameter, argument);
     });
 
@@ skipping 138 matching lines @@
           InitializingFormalElement fieldParameterElement = parameter;
           fieldValues[fieldParameterElement.fieldElement] = argument;
         }
       });
 
       // Build the initializers in the context of the new constructor.
       ResolvedAst oldResolvedAst = resolvedAst;
       resolvedAst = callee.resolvedAst;
       final oldElementInferenceResults = elementInferenceResults;
       elementInferenceResults = globalInferenceResults.resultOfMember(callee);
-      ClosureRepresentationInfo oldClosureData = localsHandler.closureData;
-      ClosureRepresentationInfo newClosureData =
-          closureDataLookup.getClosureRepresentationInfo(callee);
-      localsHandler.closureData = newClosureData;
+      ScopeInfo oldScopeInfo = localsHandler.scopeInfo;
+      ScopeInfo newScopeInfo = closureDataLookup.getScopeInfo(callee);
+      localsHandler.scopeInfo = newScopeInfo;
       if (resolvedAst.kind == ResolvedAstKind.PARSED) {
         localsHandler.enterScope(
             closureDataLookup.getClosureAnalysisInfo(resolvedAst.node),
             forGenerativeConstructorBody: callee.isGenerativeConstructorBody);
       }
       buildInitializers(callee, constructorResolvedAsts, fieldValues);
-      localsHandler.closureData = oldClosureData;
+      localsHandler.scopeInfo = oldScopeInfo;
       resolvedAst = oldResolvedAst;
       elementInferenceResults = oldElementInferenceResults;
     });
   }
 
   void buildInitializers(
       ConstructorElement constructor,
       List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues) {
     assert(
@@ skipping 390 matching lines @@
 
     Map<Local, TypeMask> parameters = <Local, TypeMask>{};
     if (element is MethodElement) {
       element.functionSignature.orderedForEachParameter((_parameter) {
         ParameterElement parameter = _parameter;
         parameters[parameter] = TypeMaskFactory.inferredTypeForParameter(
             parameter, globalInferenceResults);
       });
     }
 
-    ClosureRepresentationInfo closureData =
-        closureDataLookup.getClosureRepresentationInfo(element);
-    localsHandler.startFunction(element, closureData,
-        closureDataLookup.getClosureAnalysisInfo(node), parameters,
+    localsHandler.startFunction(
+        element,
+        closureDataLookup.getScopeInfo(element),
+        closureDataLookup.getClosureAnalysisInfo(node),
+        parameters,
         isGenerativeConstructorBody: element.isGenerativeConstructorBody);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
     // Add the type parameters of the class as parameters of this method.  This
     // must be done before adding the normal parameters, because their types
     // may contain references to type variables.
     ClassElement cls = element.enclosingClass;
     if ((element.isConstructor || element.isGenerativeConstructorBody) &&
@@ skipping 5406 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }