dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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.ir_nodes;
 
 import 'dart:collection';
 import 'cps_fragment.dart' show CpsFragment;
 import 'cps_ir_nodes_sexpr.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
@@ skipping 405 matching lines @@
 /// continuation to invoke when returning from the function.
 class FunctionDefinition extends InteriorNode {
   final ExecutableElement element;
   Parameter interceptorParameter;
   final Parameter receiverParameter;
   final List<Parameter> parameters;
   final Continuation returnContinuation;
   final SourceInformation sourceInformation;
   Expression body;
 
-  FunctionDefinition(
-      this.element,
-      this.receiverParameter,
-      this.parameters,
-      this.returnContinuation,
-      this.body,
-      {this.interceptorParameter,
-       this.sourceInformation});
+  FunctionDefinition(this.element, this.receiverParameter, this.parameters,
+      this.returnContinuation, this.body,
+      {this.interceptorParameter, this.sourceInformation});
 
   accept(BlockVisitor visitor) => visitor.visitFunctionDefinition(this);
 
   void setParentPointers() {
     if (interceptorParameter != null) interceptorParameter.parent = this;
     if (receiverParameter != null) receiverParameter.parent = this;
     _setParentsOnNodes(parameters, this);
     returnContinuation.parent = this;
     if (body != null) body.parent = this;
   }
@@ skipping 117 matching lines @@
   TypeMask mask;
   final List<Reference<Primitive>> argumentRefs;
   final SourceInformation sourceInformation;
   CallingConvention _callingConvention;
 
   CallingConvention get callingConvention => _callingConvention;
 
   InvokeMethod(
       Primitive receiver, this.selector, this.mask, List<Primitive> arguments,
       {this.sourceInformation,
-       CallingConvention callingConvention,
-       Primitive interceptor})
+      CallingConvention callingConvention,
+      Primitive interceptor})
       : this.receiverRef = new Reference<Primitive>(receiver),
         this.argumentRefs = _referenceList(arguments),
         this.interceptorRef = _optionalReference(interceptor),
         this._callingConvention = callingConvention ??
             (interceptor != null
                 ? CallingConvention.Intercepted
                 : CallingConvention.Normal);
 
   accept(Visitor visitor) => visitor.visitInvokeMethod(this);
 
@@ skipping 554 matching lines @@
 ///
 ///   { [variable] := [value]; [body] }
 class SetMutable extends Primitive {
   final Reference<MutableVariable> variableRef;
   final Reference<Primitive> valueRef;
   final SourceInformation sourceInformation;
 
   MutableVariable get variable => variableRef.definition;
   Primitive get value => valueRef.definition;
 
-  SetMutable(
-      MutableVariable variable,
-      Primitive value,
+  SetMutable(MutableVariable variable, Primitive value,
       {this.sourceInformation})
       : this.variableRef = new Reference<MutableVariable>(variable),
         this.valueRef = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetMutable(this);
 
   bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
@@ skipping 14 matching lines @@
   /// True if the field never changes value.
   final bool isFinal;
 
   /// True if the object is known not to be null.
   // TODO(asgerf): This is a placeholder until we agree on how to track
   //               side effects.
   bool objectIsNotNull = false;
 
   Primitive get object => objectRef.definition;
 
-  GetField(
-      Primitive object,
-      this.field,
-      {this.sourceInformation,
-       this.isFinal: false})
+  GetField(Primitive object, this.field,
+      {this.sourceInformation, this.isFinal: false})
       : this.objectRef = new Reference<Primitive>(object);
 
   accept(Visitor visitor) => visitor.visitGetField(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => objectIsNotNull;
   bool get isSafeForReordering => false;
 
   toString() => 'GetField($field)';
 
   void setParentPointers() {
     objectRef.parent = this;
   }
 
   int get effects => isFinal ? 0 : Effects.dependsOnInstanceField;
 }
 
 /// Directly assigns to a field on a given object.
 class SetField extends Primitive {
   final Reference<Primitive> objectRef;
   FieldElement field;
   final Reference<Primitive> valueRef;
   final SourceInformation sourceInformation;
 
   Primitive get object => objectRef.definition;
   Primitive get value => valueRef.definition;
 
-  SetField(
-      Primitive object,
-      this.field,
-      Primitive value,
+  SetField(Primitive object, this.field, Primitive value,
       {this.sourceInformation})
       : this.objectRef = new Reference<Primitive>(object),
         this.valueRef = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetField(this);
 
   bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
@@ skipping 311 matching lines @@
   final js.Template codeTemplate;
   final TypeMask storedType;
   final List<Reference<Primitive>> argumentRefs;
   final native.NativeBehavior nativeBehavior;
   final SourceInformation sourceInformation;
   final FunctionElement dependency;
 
   Primitive argument(int n) => argumentRefs[n].definition;
   Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);
 
-  ForeignCode(
-      this.codeTemplate,
-      this.storedType,
-      List<Primitive> arguments,
-      this.nativeBehavior,
-      this.sourceInformation,
+  ForeignCode(this.codeTemplate, this.storedType, List<Primitive> arguments,
+      this.nativeBehavior, this.sourceInformation,
       {this.dependency})
       : this.argumentRefs = _referenceList(arguments) {
     effects = Effects.from(nativeBehavior.sideEffects);
   }
 
   accept(Visitor visitor) => visitor.visitForeignCode(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
@@ skipping 510 matching lines @@
   Continuation get trueContinuation => trueContinuationRef.definition;
   Continuation get falseContinuation => falseContinuationRef.definition;
 
   /// If true, only the value `true` satisfies the condition. Otherwise, any
   /// truthy value satisfies the check.
   ///
   /// Non-strict checks are preferable when the condition is known to be a
   /// boolean.
   bool isStrictCheck;
 
-  Branch(
-      Primitive condition,
-      Continuation trueCont,
-      Continuation falseCont,
+  Branch(Primitive condition, Continuation trueCont, Continuation falseCont,
       this.sourceInformation,
       {bool strict})
       : this.conditionRef = new Reference<Primitive>(condition),
         trueContinuationRef = new Reference<Continuation>(trueCont),
         falseContinuationRef = new Reference<Continuation>(falseCont),
         isStrictCheck = strict {
     assert(strict != null);
   }
 
-  Branch.strict(
-      Primitive condition,
-      Continuation trueCont,
-      Continuation falseCont,
-      SourceInformation sourceInformation)
+  Branch.strict(Primitive condition, Continuation trueCont,
+      Continuation falseCont, SourceInformation sourceInformation)
       : this(condition, trueCont, falseCont, sourceInformation, strict: true);
 
-  Branch.loose(
-      Primitive condition,
-      Continuation trueCont,
-      Continuation falseCont,
-      SourceInformation sourceInformation)
+  Branch.loose(Primitive condition, Continuation trueCont,
+      Continuation falseCont, SourceInformation sourceInformation)
       : this(condition, trueCont, falseCont, sourceInformation, strict: false);
 
   accept(BlockVisitor visitor) => visitor.visitBranch(this);
 
   void setParentPointers() {
     conditionRef.parent = this;
     trueContinuationRef.parent = this;
     falseContinuationRef.parent = this;
   }
 }
@@ skipping 759 matching lines @@
   Definition visitLiteralList(LiteralList node) {
     return new LiteralList(node.dartType, getList(node.valueRefs))
       ..allocationSiteType = node.allocationSiteType;
   }
 
   Definition visitConstant(Constant node) {
     return new Constant(node.value, sourceInformation: node.sourceInformation);
   }
 
   Definition visitGetMutable(GetMutable node) {
-    return new GetMutable(
-        getCopy(node.variableRef), sourceInformation: node.sourceInformation);
+    return new GetMutable(getCopy(node.variableRef),
+        sourceInformation: node.sourceInformation);
   }
 
   Definition visitParameter(Parameter node) {
     return new Parameter(node.hint);
   }
 
   Definition visitMutableVariable(MutableVariable node) {
     return new MutableVariable(node.hint);
   }
 
@@ skipping 94 matching lines @@
   Definition visitReceiverCheck(ReceiverCheck node) {
     return new ReceiverCheck(
         getCopy(node.valueRef), node.selector, node.sourceInformation,
         condition: getCopyOrNull(node.conditionRef),
         useSelector: node.useSelector,
         isNullCheck: node.isNullCheck);
   }
 
   Definition visitForeignCode(ForeignCode node) {
     return new ForeignCode(node.codeTemplate, node.storedType,
-        getList(node.argumentRefs), node.nativeBehavior,
-        node.sourceInformation,
+        getList(node.argumentRefs), node.nativeBehavior, node.sourceInformation,
         dependency: node.dependency);
   }
 }
 
 /// A trampolining visitor to copy [FunctionDefinition]s.
 class CopyingVisitor extends TrampolineRecursiveVisitor {
   // The visitor maintains a map from original continuations to their copies.
   Map<Continuation, Continuation> _copies = <Continuation, Continuation>{};
 
   // The visitor uses an auxiliary visitor to copy definitions.
@@ skipping 126 matching lines @@
         _definitions.getCopy(node.conditionRef),
         _copies[node.trueContinuation],
         _copies[node.falseContinuation],
         node.sourceInformation)..isStrictCheck = node.isStrictCheck);
   }
 
   visitUnreachable(Unreachable node) {
     plug(new Unreachable());
   }
 }