Reformat

src/analysis/scoping_analysis.cpp

@@ -278,8 +278,10 @@ private:
     bool globals_from_module;
 
 public:
-    ScopeInfoBase(ScopeInfo* parent, ScopingAnalysis::ScopeNameUsage* usage, AST* ast, bool usesNameLookup, bool globals_from_module)
-        : parent(parent), usage(usage), ast(ast), usesNameLookup_(usesNameLookup), allDerefVarsAndInfoCached(false), globals_from_module(globals_from_module) {
+    ScopeInfoBase(ScopeInfo* parent, ScopingAnalysis::ScopeNameUsage* usage, AST* ast, bool usesNameLookup,
+                  bool globals_from_module)
+        : parent(parent), usage(usage), ast(ast), usesNameLookup_(usesNameLookup), allDerefVarsAndInfoCached(false),
+          globals_from_module(globals_from_module) {
         assert(usage);
         assert(ast);
 
@@ -817,8 +819,8 @@ void ScopingAnalysis::processNameUsages(ScopingAnalysis::NameUsageMap* usages) {
 
         switch (node->type) {
             case AST_TYPE::ClassDef: {
-                ScopeInfoBase* scopeInfo
-                    = new ScopeInfoBase(parent_info, usage, usage->node, true /* usesNameLookup */, globals_from_module);
+                ScopeInfoBase* scopeInfo = new ScopeInfoBase(parent_info, usage, usage->node, true /* usesNameLookup */,
+                                                             globals_from_module);
                 this->scopes[node] = scopeInfo;
                 break;
             }
@@ -827,10 +829,11 @@ void ScopingAnalysis::processNameUsages(ScopingAnalysis::NameUsageMap* usages) {
             case AST_TYPE::GeneratorExp:
             case AST_TYPE::DictComp:
             case AST_TYPE::SetComp: {
-                ScopeInfoBase* scopeInfo = new ScopeInfoBase(parent_info, usage, usage->node,
-                                                             usage->hasNameForcingSyntax() /* usesNameLookup */,
-                                                             globals_from_module);
-                this->scopes[node] = scopeInfo; break;
+                ScopeInfoBase* scopeInfo
+                    = new ScopeInfoBase(parent_info, usage, usage->node,
+                                        usage->hasNameForcingSyntax() /* usesNameLookup */, globals_from_module);
+                this->scopes[node] = scopeInfo;
+                break;
             }
             default:
                 RELEASE_ASSERT(0, "%d", usage->node->type);
@@ -884,16 +887,19 @@ ScopeInfo* ScopingAnalysis::getScopeInfoForNode(AST* node) {
     return analyzeSubtree(node);
 }
 
-ScopingAnalysis::ScopingAnalysis(AST_Module* m) : parent_module(m), interned_strings(*m->interned_strings.get()), globals_from_module(true) {
+ScopingAnalysis::ScopingAnalysis(AST_Module* m)
+    : parent_module(m), interned_strings(*m->interned_strings.get()), globals_from_module(true) {
     scopes[m] = new ModuleScopeInfo();
 }
 
-ScopingAnalysis::ScopingAnalysis(AST_Expression* e, bool globals_from_module) : interned_strings(*e->interned_strings.get()), globals_from_module(globals_from_module) {
+ScopingAnalysis::ScopingAnalysis(AST_Expression* e, bool globals_from_module)
+    : interned_strings(*e->interned_strings.get()), globals_from_module(globals_from_module) {
     // It's an expression, so it can't have a `global` statement
     scopes[e] = new EvalExprScopeInfo(globals_from_module);
 }
 
-ScopingAnalysis::ScopingAnalysis(AST_Suite* s, bool globals_from_module) : interned_strings(*s->interned_strings.get()), globals_from_module(globals_from_module) {
+ScopingAnalysis::ScopingAnalysis(AST_Suite* s, bool globals_from_module)
+    : interned_strings(*s->interned_strings.get()), globals_from_module(globals_from_module) {
     scopes[s] = new EvalExprScopeInfo(s, globals_from_module);
 }
 }

src/codegen/ast_interpreter.cpp

@@ -742,7 +742,8 @@ Box* ASTInterpreter::createFunction(AST* node, AST_arguments* args, const std::v
         }
         assert(closure);
     }
-    return boxCLFunction(cl, closure, is_generator, globals->cls == dict_cls ? static_cast<BoxedDict*>(globals) : NULL, u.il);
+    return boxCLFunction(cl, closure, is_generator, globals->cls == dict_cls ? static_cast<BoxedDict*>(globals) : NULL,
+                         u.il);
 }
 
 Value ASTInterpreter::visit_makeFunction(AST_MakeFunction* mkfn) {
@@ -778,7 +779,9 @@ Value ASTInterpreter::visit_makeClass(AST_MakeClass* mkclass) {
 
     BoxedClosure* closure = scope_info->takesClosure() ? created_closure : 0;
     CLFunction* cl = wrapFunction(node, nullptr, node->body, source_info);
-    Box* attrDict = runtimeCall(boxCLFunction(cl, closure, false, globals->cls == dict_cls ? static_cast<BoxedDict*>(globals) : NULL, {}), ArgPassSpec(0), 0, 0, 0, 0, 0);
+    Box* attrDict = runtimeCall(
+        boxCLFunction(cl, closure, false, globals->cls == dict_cls ? static_cast<BoxedDict*>(globals) : NULL, {}),
+        ArgPassSpec(0), 0, 0, 0, 0, 0);
 
     Box* classobj = createUserClass(&node->name.str(), basesTuple, attrDict);
 
@@ -1164,8 +1167,8 @@ Value ASTInterpreter::visit_attribute(AST_Attribute* node) {
 
 const void* interpreter_instr_addr = (void*)&ASTInterpreter::execute;
 
-Box* astInterpretFunction(CompiledFunction* cf, int nargs, Box* closure, Box* generator, BoxedDict* globals, Box* arg1, Box* arg2,
-                          Box* arg3, Box** args) {
+Box* astInterpretFunction(CompiledFunction* cf, int nargs, Box* closure, Box* generator, BoxedDict* globals, Box* arg1,
+                          Box* arg2, Box* arg3, Box** args) {
     if (unlikely(cf->times_called > REOPT_THRESHOLD_INTERPRETER && ENABLE_REOPT && !FORCE_INTERPRETER)) {
         CompiledFunction* optimized = reoptCompiledFuncInternal(cf);
         if (closure && generator)

src/codegen/ast_interpreter.h

@@ -33,8 +33,8 @@ struct LineInfo;
 
 extern const void* interpreter_instr_addr;
 
-Box* astInterpretFunction(CompiledFunction* f, int nargs, Box* closure, Box* generator, BoxedDict* globals, Box* arg1, Box* arg2, Box* arg3,
-                          Box** args);
+Box* astInterpretFunction(CompiledFunction* f, int nargs, Box* closure, Box* generator, BoxedDict* globals, Box* arg1,
+                          Box* arg2, Box* arg3, Box** args);
 Box* astInterpretFunctionEval(CompiledFunction* cf, BoxedDict* globals, Box* boxedLocals);
 Box* astInterpretFrom(CompiledFunction* cf, AST_expr* after_expr, AST_stmt* enclosing_stmt, Box* expr_val,
                       FrameStackState frame_state);

src/runtime/generator.cpp

@@ -95,7 +95,8 @@ void generatorEntry(BoxedGenerator* g) {
         BoxedFunctionBase* func = g->function;
 
         Box** args = g->args ? &g->args->elts[0] : nullptr;
-        callCLFunc(func->f, nullptr, func->f->numReceivedArgs(), func->closure, g, func->globals, g->arg1, g->arg2, g->arg3, args);
+        callCLFunc(func->f, nullptr, func->f->numReceivedArgs(), func->closure, g, func->globals, g->arg1, g->arg2,
+                   g->arg3, args);
     } catch (ExcInfo e) {
         // unhandled exception: propagate the exception to the caller
         g->exception = e;

src/runtime/objmodel.cpp

@@ -2936,7 +2936,8 @@ Box* callCLFunc(CLFunction* f, CallRewriteArgs* rewrite_args, int num_output_arg
 
     assert(chosen_cf->is_interpreted == (chosen_cf->code == NULL));
     if (chosen_cf->is_interpreted) {
-        return astInterpretFunction(chosen_cf, num_output_args, closure, generator, globals, oarg1, oarg2, oarg3, oargs);
+        return astInterpretFunction(chosen_cf, num_output_args, closure, generator, globals, oarg1, oarg2, oarg3,
+                                    oargs);
     }
 
     if (rewrite_args) {