Refactor BackendHelpers to be reusageable with KernelWorldBuilder

pkg/compiler/lib/src/resolution/members.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.
 
 library dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../common/resolution.dart' show Resolution;
 import '../compile_time_constants.dart';
@@ skipping 2844 matching lines @@
             : new StaticAccess.staticMethod(method);
       } else {
         // `a = b`, `a++` or `a += b` where `a` is a field.
         assert(invariant(node, member.isField,
             message: "Unexpected element: $member."));
         if (node.isComplex) {
           // `a++` or `a += b` where `a` is a field.
           registry.registerStaticUse(new StaticUse.staticGet(member));
         }
         if (member.isFinal || member.isConst) {
-          reportAndCreateErroneousElement(
-              node.selector,
-              name.text,
-              MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER,
-              {'name': name});
+          reportAndCreateErroneousElement(node.selector, name.text,
+              MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER, {'name': name});
           registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           semantics = member.isTopLevel
               ? new StaticAccess.finalTopLevelField(member)
               : new StaticAccess.finalStaticField(member);
         } else {
           registry.registerStaticUse(new StaticUse.staticSet(member));
           semantics = member.isTopLevel
               ? new StaticAccess.topLevelField(member)
               : new StaticAccess.staticField(member);
         }
@@ skipping 727 matching lines @@
         reporter.reportErrorMessage(node, MessageKind.RETURN_IN_GENERATOR,
             {'modifier': currentAsyncMarker});
       }
     }
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitYield(Yield node) {
     if (!resolution.target.supportsAsyncAwait) {
-      reporter.reportErrorMessage(
-          reporter.spanFromToken(node.yieldToken),
+      reporter.reportErrorMessage(reporter.spanFromToken(node.yieldToken),
           MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
     } else {
       if (!currentAsyncMarker.isYielding) {
         reporter.reportErrorMessage(node, MessageKind.INVALID_YIELD);
       }
       ClassElement cls;
       if (currentAsyncMarker.isAsync) {
         cls = commonElements.streamClass;
       } else {
         cls = commonElements.iterableClass;
@@ skipping 120 matching lines @@
   }
 
   ResolutionResult visitThrow(Throw node) {
     registry.registerFeature(Feature.THROW_EXPRESSION);
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitAwait(Await node) {
     if (!resolution.target.supportsAsyncAwait) {
-      reporter.reportErrorMessage(
-          reporter.spanFromToken(node.awaitToken),
+      reporter.reportErrorMessage(reporter.spanFromToken(node.awaitToken),
           MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
     } else {
       if (!currentAsyncMarker.isAsync) {
         reporter.reportErrorMessage(node, MessageKind.INVALID_AWAIT);
       }
       ClassElement futureClass = commonElements.futureClass;
       futureClass.ensureResolved(resolution);
     }
     visit(node.expression);
     return const NoneResult();
@@ skipping 244 matching lines @@
           registry.registerNewStructure(node, structure.resolve(node));
         };
       }
 
       analyzeConstantDeferred(node, onAnalyzed: onAnalyzed);
     } else {
       // Not constant.
       if (resolution.commonElements.isSymbolConstructor(constructor) &&
           !resolution.mirrorUsageAnalyzerTask
               .hasMirrorUsage(enclosingElement)) {
-        reporter.reportHintMessage(reporter.spanFromToken(node.newToken),
+        reporter.reportHintMessage(
+            reporter.spanFromToken(node.newToken),
             MessageKind.NON_CONST_BLOAT,
             {'name': commonElements.symbolClass.name});
       }
       registry.registerNewStructure(
           node,
           new NewInvokeStructure(
               new ConstructorAccessSemantics(kind, constructor, type),
               selector));
     }
 
@@ skipping 251 matching lines @@
       }
       label.setContinueTarget();
       registry.useLabel(node, label);
     }
     registry.registerTargetOf(node, target);
     return const NoneResult();
   }
 
   ResolutionResult visitAsyncForIn(AsyncForIn node) {
     if (!resolution.target.supportsAsyncAwait) {
-      reporter.reportErrorMessage(
-          reporter.spanFromToken(node.awaitToken),
+      reporter.reportErrorMessage(reporter.spanFromToken(node.awaitToken),
           MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
     } else {
       if (!currentAsyncMarker.isAsync) {
-        reporter.reportErrorMessage(
-            reporter.spanFromToken(node.awaitToken),
+        reporter.reportErrorMessage(reporter.spanFromToken(node.awaitToken),
             MessageKind.INVALID_AWAIT_FOR_IN);
       }
       registry.registerFeature(Feature.ASYNC_FOR_IN);
       registry.registerDynamicUse(new DynamicUse(Selectors.current, null));
       registry.registerDynamicUse(new DynamicUse(Selectors.moveNext, null));
     }
     visit(node.expression);
 
     Scope blockScope = new BlockScope(scope);
     visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
@@ skipping 477 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }