CompilationInfo.h

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef frontend_CompilationInfo_h
#define frontend_CompilationInfo_h

#include "mozilla/Attributes.h"
#include "mozilla/RefPtr.h"
#include "mozilla/Variant.h"

#include "ds/LifoAlloc.h"
#include "frontend/ParserAtom.h"
#include "frontend/SharedContext.h"
#include "frontend/Stencil.h"
#include "frontend/UsedNameTracker.h"
#include "js/GCVariant.h"
#include "js/GCVector.h"
#include "js/HashTable.h"
#include "js/RealmOptions.h"
#include "js/SourceText.h"
#include "js/Vector.h"
#include "js/WasmModule.h"
#include "vm/JSContext.h"
#include "vm/JSFunction.h"  // JSFunction
#include "vm/JSScript.h"    // SourceExtent
#include "vm/Realm.h"

namespace js {
namespace frontend {

// ScopeContext hold information derivied from the scope and environment chains
// to try to avoid the parser needing to traverse VM structures directly.
struct ScopeContext {
  // Whether the enclosing scope allows certain syntax. Eval and arrow scripts
  // inherit this from their enclosing scipt so we track it here.
  bool allowNewTarget = false;
  bool allowSuperProperty = false;
  bool allowSuperCall = false;
  bool allowArguments = true;

  // The type of binding required for `this` of the top level context, as
  // indicated by the enclosing scopes of this parse.
  ThisBinding thisBinding = ThisBinding::Global;

  // Somewhere on the scope chain this parse is embedded within is a 'With'
  // scope.
  bool inWith = false;

  // Somewhere on the scope chain this parse is embedded within a class scope.
  bool inClass = false;

  // Class field initializer info if we are nested within a class constructor.
  // We may be an combination of arrow and eval context within the constructor.
  mozilla::Maybe<FieldInitializers> fieldInitializers = {};

  explicit ScopeContext(Scope* scope, JSObject* enclosingEnv = nullptr) {
    computeAllowSyntax(scope);
    computeThisBinding(scope, enclosingEnv);
    computeInWith(scope);
    computeExternalInitializers(scope);
    computeInClass(scope);
  }

 private:
  void computeAllowSyntax(Scope* scope);
  void computeThisBinding(Scope* scope, JSObject* environment = nullptr);
  void computeInWith(Scope* scope);
  void computeExternalInitializers(Scope* scope);
  void computeInClass(Scope* scope);
};

struct CompilationInfo;

class ScriptStencilIterable {
 public:
  class ScriptAndFunction {
   public:
    ScriptStencil& stencil;
    HandleFunction function;
    FunctionIndex functionIndex;

    ScriptAndFunction() = delete;
    ScriptAndFunction(ScriptStencil& stencil, HandleFunction function,
                      FunctionIndex functionIndex)
        : stencil(stencil), function(function), functionIndex(functionIndex) {}
  };

  class Iterator {
    enum class State {
      TopLevel,
      Functions,
    };
    State state_ = State::TopLevel;
    size_t index_ = 0;
    CompilationInfo* compilationInfo_;

    Iterator(CompilationInfo* compilationInfo, State state, size_t index)
        : state_(state), index_(index), compilationInfo_(compilationInfo) {
      skipNonFunctions();
    }

   public:
    explicit Iterator(CompilationInfo* compilationInfo)
        : compilationInfo_(compilationInfo) {
      skipNonFunctions();
    }

    Iterator operator++() {
      next();
      skipNonFunctions();
      return *this;
    }

    inline void next();

    inline void skipNonFunctions();

    bool operator!=(const Iterator& other) const {
      return state_ != other.state_ || index_ != other.index_;
    }

    inline ScriptAndFunction operator*();

    static inline Iterator end(CompilationInfo* compilationInfo);
  };

  CompilationInfo* compilationInfo_;

  explicit ScriptStencilIterable(CompilationInfo* compilationInfo)
      : compilationInfo_(compilationInfo) {}

  Iterator begin() const { return Iterator(compilationInfo_); }

  Iterator end() const { return Iterator::end(compilationInfo_); }
};

// CompilationInfo owns a number of pieces of information about script
// compilation as well as controls the lifetime of parse nodes and other data by
// controling the mark and reset of the LifoAlloc.
struct MOZ_RAII CompilationInfo : public JS::CustomAutoRooter {
  static constexpr FunctionIndex TopLevelFunctionIndex = FunctionIndex(0);

  JSContext* cx;
  const JS::ReadOnlyCompileOptions& options;

  // Until we have dealt with Atoms in the front end, we need to hold
  // onto them.
  AutoKeepAtoms keepAtoms;

  // Table of parser atoms for this compilation.
  ParserAtomsTable parserAtoms;

  Directives directives;

  ScopeContext scopeContext;

  // List of function contexts for GC tracing. These are allocated in the
  // LifoAlloc and still require tracing.
  FunctionBox* traceListHead = nullptr;

  // The resulting outermost script for the compilation powered
  // by this CompilationInfo.
  JS::Rooted<JSScript*> script;
  JS::Rooted<BaseScript*> lazy;

  UsedNameTracker usedNames;
  LifoAllocScope& allocScope;

  // Hold onto the RegExpCreationData and BigIntCreationData that are allocated
  // during parse to ensure correct destruction.
  Vector<RegExpCreationData> regExpData;
  Vector<BigIntCreationData> bigIntData;

  // A Rooted vector to handle tracing of JSFunction*
  // and Atoms within.
  JS::RootedVector<JSFunction*> functions;
  JS::RootedVector<ScriptStencil> funcData;

  // The enclosing scope of the function if we're compiling standalone function.
  // Null otherwise.
  JS::Rooted<Scope*> topLevelFunctionEnclosingScope;

  // Stencil for top-level script. This includes standalone functions and
  // functions being delazified.
  JS::Rooted<ScriptStencil> topLevel;

  // A rooted list of scopes created during this parse.
  //
  // To ensure that ScopeCreationData's destructors fire, and thus our HeapPtr
  // barriers, we store the scopeCreationData at this level so that they
  // can be safely destroyed, rather than LifoAllocing them with the rest of
  // the parser data structures.
  //
  // References to scopes are controlled via AbstractScopePtr, which holds onto
  // an index (and CompilationInfo reference).
  JS::RootedVector<ScopeCreationData> scopeCreationData;

  // AsmJS modules generated by parsing.
  HashMap<FunctionIndex, RefPtr<const JS::WasmModule>> asmJS;

  JS::Rooted<ScriptSourceObject*> sourceObject;

  // Track the state of key allocations and roll them back as parts of parsing
  // get retried. This ensures iteration during stencil instantiation does not
  // encounter discarded frontend state.
  struct RewindToken {
    FunctionBox* funbox = nullptr;
    size_t funcDataLength = 0;
  };

  RewindToken getRewindToken();
  void rewind(const RewindToken& pos);

  // Construct a CompilationInfo
  CompilationInfo(JSContext* cx, LifoAllocScope& alloc,
                  const JS::ReadOnlyCompileOptions& options,
                  Scope* enclosingScope = nullptr,
                  JSObject* enclosingEnv = nullptr)
      : JS::CustomAutoRooter(cx),
        cx(cx),
        options(options),
        keepAtoms(cx),
        parserAtoms(cx),
        directives(options.forceStrictMode()),
        scopeContext(enclosingScope, enclosingEnv),
        script(cx),
        lazy(cx),
        usedNames(cx),
        allocScope(alloc),
        regExpData(cx),
        bigIntData(cx),
        functions(cx),
        funcData(cx),
        topLevelFunctionEnclosingScope(cx),
        topLevel(cx),
        scopeCreationData(cx),
        asmJS(cx),
        sourceObject(cx) {}

  bool init(JSContext* cx);

  bool initForStandaloneFunction(JSContext* cx, HandleScope enclosingScope) {
    if (!init(cx)) {
      return false;
    }
    this->topLevelFunctionEnclosingScope = enclosingScope;
    return true;
  }

  void initFromLazy(BaseScript* lazy) {
    this->lazy = lazy;
    this->sourceObject = lazy->sourceObject();
    this->topLevelFunctionEnclosingScope = lazy->function()->enclosingScope();
  }

  void setTopLevelFunctionEnclosingScope(Scope* scope) {
    topLevelFunctionEnclosingScope = scope;
  }

  template <typename Unit>
  MOZ_MUST_USE bool assignSource(JS::SourceText<Unit>& sourceBuffer) {
    return sourceObject->source()->assignSource(cx, options, sourceBuffer);
  }

  MOZ_MUST_USE bool instantiateStencils();

  void trace(JSTracer* trc) final;

  // To avoid any misuses, make sure this is neither copyable,
  // movable or assignable.
  CompilationInfo(const CompilationInfo&) = delete;
  CompilationInfo(CompilationInfo&&) = delete;
  CompilationInfo& operator=(const CompilationInfo&) = delete;
  CompilationInfo& operator=(CompilationInfo&&) = delete;

  ScriptStencilIterable functionScriptStencils() {
    return ScriptStencilIterable(this);
  }
};

inline void ScriptStencilIterable::Iterator::next() {
  if (state_ == State::TopLevel) {
    state_ = State::Functions;
  } else {
    MOZ_ASSERT(index_ < compilationInfo_->funcData.length());
    index_++;
  }
}

inline void ScriptStencilIterable::Iterator::skipNonFunctions() {
  if (state_ == State::TopLevel) {
    if (compilationInfo_->topLevel.get().isFunction()) {
      return;
    }

    next();
  }

  size_t length = compilationInfo_->funcData.length();
  while (index_ < length) {
    // NOTE: If topLevel is a function, funcData can contain unused item,
    //       and the item isn't marked as a function.
    if (compilationInfo_->funcData[index_].get().isFunction()) {
      return;
    }

    index_++;
  }
}

inline ScriptStencilIterable::ScriptAndFunction
ScriptStencilIterable::Iterator::operator*() {
  ScriptStencil& stencil = state_ == State::TopLevel
                               ? compilationInfo_->topLevel.get()
                               : compilationInfo_->funcData[index_].get();

  FunctionIndex functionIndex = FunctionIndex(
      state_ == State::TopLevel ? CompilationInfo::TopLevelFunctionIndex
                                : index_);
  return ScriptAndFunction(stencil, compilationInfo_->functions[functionIndex],
                           functionIndex);
}

/* static */ inline ScriptStencilIterable::Iterator
ScriptStencilIterable::Iterator::end(CompilationInfo* compilationInfo) {
  return Iterator(compilationInfo, State::Functions,
                  compilationInfo->funcData.length());
}

}  // namespace frontend
}  // namespace js
#endif