com.shapesecurity.shift.scope.Scope Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of shift Show documentation
Shift format ECMAScript 6 AST tooling
There is a newer version: 2.2.0
/*
 * Copyright 2014 Shape Security, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.shapesecurity.shift.scope;

import com.shapesecurity.functional.Pair;
import com.shapesecurity.functional.data.HashTable;
import com.shapesecurity.functional.data.ImmutableList;
import com.shapesecurity.functional.data.Maybe;
import com.shapesecurity.shift.ast.BindingIdentifier;
import com.shapesecurity.shift.ast.FunctionDeclaration;
import com.shapesecurity.shift.ast.IdentifierExpression;
import com.shapesecurity.shift.ast.Node;

import org.jetbrains.annotations.NotNull;

import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;

public class Scope {

    @NotNull
    public final Node astNode;
    @NotNull
    public final HashTable> through;
    @NotNull
    public final ImmutableList children;
    @NotNull
    public final Type type;
    public final boolean dynamic;
    protected final Map variables = new LinkedHashMap<>();

    Scope(
            @NotNull ImmutableList children,
            @NotNull ImmutableList variables,
            @NotNull HashTable> through,
            @NotNull Type type,
            boolean isDynamic,
            @NotNull Node astNode) {
        this.children = children;
        this.through = through;
        this.type = type;
        this.astNode = astNode;

        for (Variable var : variables) {
            this.variables.put(var.name, var);
        }

        this.dynamic = isDynamic || type == Type.With;
    }

    public boolean isGlobal() {
        return (this.type == Type.Global);
    }

    @NotNull
    public final Maybe lookupVariable(@NotNull String name) {
        return Maybe.fromNullable(this.variables.get(name));
    }

    @NotNull
    public final Collection variables() {
        return this.variables.values();
    }


    public enum Type {
        Global,
        Module,
        Script,
        ArrowFunction,
        Function,
        FunctionName,
        Parameters,
        ParameterExpression,
        With,
        Catch,
        Block
    }
}