[wasm] asm.js - Parse and convert asm.js to wasm a function at a time.

src/ast/scopes.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/ast/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/ast/ast.h"
@@ skipping 528 matching lines @@
 
   if (scope->is_eval_scope() && is_sloppy(scope->language_mode())) {
     AstNodeFactory factory(info->ast_value_factory());
     scope->HoistSloppyBlockFunctions(&factory);
   }
 
   // We are compiling one of three cases:
   // 1) top-level code,
   // 2) a function/eval/module on the top-level
   // 3) a function/eval in a scope that was already resolved.
-  DCHECK(scope->scope_type() == SCRIPT_SCOPE ||
-         scope->outer_scope()->scope_type() == SCRIPT_SCOPE ||
-         scope->outer_scope()->already_resolved_);
+  //  DCHECK(scope->scope_type() == SCRIPT_SCOPE ||

[titzer, 2016/11/28 10:40:11]

Can you explain why this DCHECK is no longer needed? And delete it...

[marja, 2016/11/28 11:10:17]

I think these commented-out-DCHECKs are stuff that fails currently and it's
still unclear why. They are not to be deleted (but might need an update, idk
yet)

[bradn, 2016/11/29 06:30:35]

Done.

[bradn, 2016/11/29 06:30:35]

Added back with new case and comment.

+  //         scope->outer_scope()->scope_type() == SCRIPT_SCOPE ||
+  //         scope->outer_scope()->already_resolved_);
 
   // The outer scope is never lazy.
   scope->set_should_eager_compile();

[titzer, 2016/11/28 10:40:11]

Fishy. I don't think we want to set eager compile on the inner asm.js
functions...

[bradn, 2016/11/29 06:30:35]

I think this ends up being moot in the asm case, as these scopes never get used
in a normal compile.

 
   scope->AllocateVariables(info, mode);
 
   // Ensuring that the outer script scope has a scope info avoids having
   // special case for native contexts vs other contexts.
   if (info->script_scope()->scope_info_.is_null()) {
     info->script_scope()->scope_info_ =
         handle(ScopeInfo::Empty(info->isolate()));
   }
 
@@ skipping 434 matching lines @@
   return var;
 }
 
 VariableProxy* Scope::NewUnresolved(AstNodeFactory* factory,
                                     const AstRawString* name,
                                     int start_position, VariableKind kind) {
   // Note that we must not share the unresolved variables with
   // the same name because they may be removed selectively via
   // RemoveUnresolved().
   DCHECK(!already_resolved_);
-  DCHECK_EQ(factory->zone(), zone());
+  //  DCHECK_EQ(factory->zone(), zone());

[titzer, 2016/11/28 10:40:11]

delete

[marja, 2016/11/28 11:47:21]

No, don't delete :)

[bradn, 2016/11/29 06:30:35]

Keeping with additional clause.

   VariableProxy* proxy = factory->NewVariableProxy(name, kind, start_position);
   proxy->set_next_unresolved(unresolved_);
   unresolved_ = proxy;
   return proxy;
 }
 
 void Scope::AddUnresolved(VariableProxy* proxy) {
   DCHECK(!already_resolved_);
   DCHECK(!proxy->is_resolved());
   proxy->set_next_unresolved(unresolved_);
@@ skipping 709 matching lines @@
   }
 #endif
 
   DCHECK_NOT_NULL(var);
   if (proxy->is_assigned()) var->set_maybe_assigned();
   if (AccessNeedsHoleCheck(var, proxy, this)) proxy->set_needs_hole_check();
   proxy->BindTo(var);
 }
 
 void Scope::ResolveVariablesRecursively(ParseInfo* info) {
-  DCHECK(info->script_scope()->is_script_scope());
+  // DCHECK(info->script_scope()->is_script_scope());

[titzer, 2016/11/28 10:40:11]

delete

[marja, 2016/11/28 11:47:21]

Ditto, don't delete; but I think this needs to be updated to reflect the
relevant condition for you. 

I guess you don't have a script scope in this case.

info->script_scope()->is_script_scope() || info->asm_function_scope() >something
something (or maybe asm_function_scope->outer_scope()->something).

[bradn, 2016/11/29 06:30:35]

Kept instead.

[bradn, 2016/11/29 06:30:35]

doing this above.
Actually this one can be kept as is.

   // Lazy parsed declaration scopes are already partially analyzed. If there are
   // unresolved references remaining, they just need to be resolved in outer
   // scopes.
   if (is_declaration_scope() && AsDeclarationScope()->is_lazily_parsed()) {
     DCHECK(variables_.occupancy() == 0);
     for (VariableProxy* proxy = unresolved_; proxy != nullptr;
          proxy = proxy->next_unresolved()) {
       Variable* var = outer_scope()->LookupRecursive(proxy, nullptr);
       if (!var->is_dynamic()) {
         var->set_is_used();
@@ skipping 321 matching lines @@
   Variable* function =
       is_function_scope() ? AsDeclarationScope()->function_var() : nullptr;
   bool is_function_var_in_context =
       function != nullptr && function->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
          (is_function_var_in_context ? 1 : 0);
 }
 
 }  // namespace internal
 }  // namespace v8