clang-format runtime/vm

runtime/vm/scopes.h

 // 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.
 
 #ifndef RUNTIME_VM_SCOPES_H_
 #define RUNTIME_VM_SCOPES_H_
 
 #include "platform/assert.h"
 #include "platform/globals.h"
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
 #include "vm/symbols.h"
 #include "vm/token.h"
 
 namespace dart {
 
 class LocalScope;
 
 
 class LocalVariable : public ZoneAllocated {
  public:
   LocalVariable(TokenPosition declaration_pos,
                 TokenPosition token_pos,
                 const String& name,
                 const AbstractType& type)
-    : declaration_pos_(declaration_pos),
-      token_pos_(token_pos),
-      name_(name),
-      owner_(NULL),
-      type_(type),
-      const_value_(NULL),
-      is_final_(false),
-      is_captured_(false),
-      is_invisible_(false),
-      is_captured_parameter_(false),
-      is_forced_stack_(false),
-      index_(LocalVariable::kUninitializedIndex) {
+      : declaration_pos_(declaration_pos),
+        token_pos_(token_pos),
+        name_(name),
+        owner_(NULL),
+        type_(type),
+        const_value_(NULL),
+        is_final_(false),
+        is_captured_(false),
+        is_invisible_(false),
+        is_captured_parameter_(false),
+        is_forced_stack_(false),
+        index_(LocalVariable::kUninitializedIndex) {
     ASSERT(type.IsZoneHandle() || type.IsReadOnlyHandle());
     ASSERT(type.IsFinalized());
     ASSERT(name.IsSymbol());
   }
 
   TokenPosition token_pos() const { return token_pos_; }
   TokenPosition declaration_token_pos() const { return declaration_pos_; }
   const String& name() const { return name_; }
   LocalScope* owner() const { return owner_; }
   void set_owner(LocalScope* owner) {
     ASSERT(owner_ == NULL);
     owner_ = owner;
   }
 
   const AbstractType& type() const { return type_; }
 
   bool is_final() const { return is_final_; }
   void set_is_final() { is_final_ = true; }
 
   bool is_captured() const { return is_captured_; }
   void set_is_captured() { is_captured_ = true; }
 
   // Variables marked as forced to stack are skipped and not captured by
   // CaptureLocalVariables - which iterates scope chain between two scopes
   // and indiscriminately marks all variables as captured.
   // TODO(27590) remove the hardcoded blacklist from CaptureLocalVariables
   bool is_forced_stack() const { return is_forced_stack_; }
   void set_is_forced_stack() { is_forced_stack_ = true; }
 
-  bool HasIndex() const {
-    return index_ != kUninitializedIndex;
-  }
+  bool HasIndex() const { return index_ != kUninitializedIndex; }
   int index() const {
     ASSERT(HasIndex());
     return index_;
   }
 
   // Assign an index to a local.
   void set_index(int index) {
     ASSERT(index != kUninitializedIndex);
     index_ = index;
   }
 
-  void set_invisible(bool value) {
-    is_invisible_ = value;
-  }
+  void set_invisible(bool value) { is_invisible_ = value; }
   bool is_invisible() const { return is_invisible_; }
 
   bool is_captured_parameter() const { return is_captured_parameter_; }
-  void set_is_captured_parameter(bool value) {
-    is_captured_parameter_ = value;
-  }
+  void set_is_captured_parameter(bool value) { is_captured_parameter_ = value; }
 
   // By convention, internal variables start with a colon.
-  bool IsInternal() const {
-    return name_.CharAt(0) == ':';
-  }
+  bool IsInternal() const { return name_.CharAt(0) == ':'; }
 
-  bool IsConst() const {
-    return const_value_ != NULL;
-  }
+  bool IsConst() const { return const_value_ != NULL; }
 
   void SetConstValue(const Instance& value) {
     ASSERT(value.IsZoneHandle() || value.IsReadOnlyHandle());
     const_value_ = &value;
   }
 
   const Instance* ConstValue() const {
     ASSERT(IsConst());
     return const_value_;
   }
 
   bool Equals(const LocalVariable& other) const;
 
   // Map the frame index to a bit-vector index.  Assumes the variable is
   // allocated to the frame.
   // var_count is the total number of stack-allocated variables including
   // all parameters.
   int BitIndexIn(intptr_t var_count) const;
 
  private:
   static const int kUninitializedIndex = INT_MIN;
 
   const TokenPosition declaration_pos_;
   const TokenPosition token_pos_;
   const String& name_;
   LocalScope* owner_;  // Local scope declaring this variable.
 
   const AbstractType& type_;  // Declaration type of local variable.
 
-  const Instance* const_value_;   // NULL or compile-time const value.
+  const Instance* const_value_;  // NULL or compile-time const value.
 
-  bool is_final_;  // If true, this variable is readonly.
+  bool is_final_;     // If true, this variable is readonly.
   bool is_captured_;  // If true, this variable lives in the context, otherwise
                       // in the stack frame.
   bool is_invisible_;
   bool is_captured_parameter_;
   bool is_forced_stack_;
   int index_;  // Allocation index in words relative to frame pointer (if not
                // captured), or relative to the context pointer (if captured).
 
   friend class LocalScope;
   DISALLOW_COPY_AND_ASSIGN(LocalVariable);
 };
 
 
 class NameReference : public ZoneAllocated {
  public:
   NameReference(TokenPosition token_pos, const String& name)
-    : token_pos_(token_pos),
-      name_(name) {
+      : token_pos_(token_pos), name_(name) {
     ASSERT(name.IsSymbol());
   }
   const String& name() const { return name_; }
   TokenPosition token_pos() const { return token_pos_; }
   void set_token_pos(TokenPosition value) { token_pos_ = value; }
+
  private:
   TokenPosition token_pos_;
   const String& name_;
 };
 
 
 class SourceLabel : public ZoneAllocated {
  public:
   enum Kind {
     kFor,
     kWhile,
     kDoWhile,
     kSwitch,
     kCase,
     kTry,
     kCatch,
     kForward,
     kStatement  // Any statement other than the above
   };
 
   SourceLabel(TokenPosition token_pos, const String& name, Kind kind)
-    : token_pos_(token_pos),
-      name_(name),
-      owner_(NULL),
-      kind_(kind) {
+      : token_pos_(token_pos), name_(name), owner_(NULL), kind_(kind) {
     ASSERT(name.IsSymbol());
   }
 
   static SourceLabel* New(TokenPosition token_pos, String* name, Kind kind) {
     if (name != NULL) {
       return new SourceLabel(token_pos, *name, kind);
     } else {
-      return new SourceLabel(token_pos,
-                             Symbols::DefaultLabel(),
-                             kind);
+      return new SourceLabel(token_pos, Symbols::DefaultLabel(), kind);
     }
   }
 
   TokenPosition token_pos() const { return token_pos_; }
   const String& name() const { return name_; }
   LocalScope* owner() const { return owner_; }
-  void set_owner(LocalScope* owner) {
-    owner_ = owner;
-  }
+  void set_owner(LocalScope* owner) { owner_ = owner; }
 
   Kind kind() const { return kind_; }
 
   // Returns the function level of the scope in which the label is defined.
   int FunctionLevel() const;
 
   bool IsUnresolved() { return kind_ == kForward; }
   void ResolveForwardReference() { kind_ = kCase; }
 
  private:
@@ skipping 162 matching lines @@
                                LocalScope** context_owner);
 
   void CollectLocalVariables(GrowableArray<VarDesc>* vars, int16_t* scope_id);
 
   NameReference* FindReference(const String& name) const;
 
   static const int kUnitializedContextLevel = INT_MIN;
   LocalScope* parent_;
   LocalScope* child_;
   LocalScope* sibling_;
-  int function_level_;  // Reflects the nesting level of local functions.
-  int loop_level_;      // Reflects the loop nesting level.
-  int context_level_;   // Reflects the level of the runtime context.
-  int num_context_variables_;   // Only set if this scope is a context owner.
+  int function_level_;         // Reflects the nesting level of local functions.
+  int loop_level_;             // Reflects the loop nesting level.
+  int context_level_;          // Reflects the level of the runtime context.
+  int num_context_variables_;  // Only set if this scope is a context owner.
   TokenPosition begin_token_pos_;  // Token index of beginning of scope.
   TokenPosition end_token_pos_;    // Token index of end of scope.
   GrowableArray<LocalVariable*> variables_;
   GrowableArray<SourceLabel*> labels_;
 
   // List of names referenced in this scope and its children that
   // are not resolved to local variables.
   GrowableArray<NameReference*> referenced_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalScope);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_SCOPES_H_