Mark a name as being global (i.e. module scoped) for name-binding and name-lookup operations in this code block and any nested scopes.

Dismantles all resources allocated by this scope.

Create a copy of the symbol table but without the links to parent, supers and children. Useful for creating instances.

Returns:Scope

the symbol table for use by the instance.

Constructs a qualified name by appending name to this scope's qname.

The indexer uses globally unique fully qualified names to address identifier definition sites. Many Python identifiers are already globally addressable using dot-separated package, class and attribute names.

Function variables and parameters are not globally addressable in the language, so the indexer uses a special path syntax for creating globally unique qualified names for them. By convention the syntax is "@" for parameters and "&" for local variables.

Parameters

name:String

a name to append to the current qname

Returns:String

the qname for name. Does not change this scope's path.

Generates a qname for a parameter of a function or method. There is not enough context for extendPath to differentiate params from locals, so callers must use this method when the name is known to be a parameter name.

Returns the containing lexical scope (which may be this scope) for lexical name lookups. In particular, it skips class scopes.

Returns the global scope (i.e. the module scope for the current module).

Find the enclosing scope-defining symbol table.

More precisely, if a form introduces a new name in the "current scope", resolving the form needs to search up the symbol-table chain until it finds the table representing the scope to which the name should be added. Used by org.python.indexer.ast.NameBinder to create new name bindings in the appropriate enclosing table with the appropriate binding type.

Find a symbol table of a certain type in the enclosing scopes.

Returns an immutable view of the table.

Returns true if name appears in a global statement in this scope or any enclosing scope.

Name binding occurs in a separate pass before the name resolution pass, building out the scope tree and binding names in the correct scopes. In this pass, the name binding and lookup rules are slightly different. This condition is transient: no scopes will be in the name-binding phase in a completed index (or module).

Returns true if this is a scope in which names may be bound.

Look up a name (String) in the current symbol table. If not found, recurse on the parent table.

Specialized version for the convenience of looking up Names. For all other types return null.

Look up an attribute in the type hierarchy. Don't look at parent link, because the enclosing scope may not be a super class. The search is "depth first, left to right" as in Python's (old) multiple inheritance rule. The new MRO can be implemented, but will probably not introduce much difference.

Parameters

supersOnly:boolean

search only in the supers' scopes, not in local table.

Look up an attribute in the local scope and superclass scopes.

See Also

lookupAttr(String, boolean)

Look up a name, but the search is bounded by a type and will not proceed to an outer scope when reaching a certain type of symbol table.

Parameters

name:String

the name to be looked up

typebound:Scope.Type

the type we wish the search to be bounded at

Look up a name, but only in the current scope.

Returns:NBinding

the local binding for name, or null.

Look up a name, but bounded by a scope defining construct. Those scopes are of type module, class, instance or function. This is used in determining the locations of a variable's definition.

Look up the scope chain for a binding named name and if found, return its type.

Look for a binding named name and if found, return its type.

Parameters

localOnly:boolean

true to look only in the current scope; if false, follows the scope chain.

Merge all records from another symbol table. Used by import from *.

Directly assigns a binding to a name in this table. Does not add a new definition or reference to the binding. This form of put is often followed by a call to Indexer#putLocation to create a reference to the binding. When there is no code location associated with id, or it is otherwise undesirable to create a reference, the Indexer#putLocation call is omitted.

Adds a definition and/or reference to the table. If there is no binding for id, creates one and gives it type and kind.

If a binding already exists, then add either a definition or a reference at loc to the binding. By convention we consider it a definition if the type changes. If the passed type is different from the binding's current type, set the binding's type to the union of the old and new types, and add a definition. If the new type is the same, just add a reference.

If the binding already exists, kind is only updated if a definition was added and the binding's type was previously the unknown type.

Same as put, but adds the name as an attribute of this scope. Looks up the superclass chain to see if the attribute exists, rather than looking in the lexical scope chain.

Returns:NBinding

the new binding, or null if the current scope does not have a properly initialized path.

Overrides java.lang.Object.toString.

Doc from java.lang.Object.toString.

Returns a string representation of the object. Satisfying this method's contract implies a non-null result must be returned.

Returns:String

a string representation of the object

Annotations

@Override

Adds a new binding for id. If a binding already existed, replaces its previous definitions, if any, with loc. Sets the binding's type to type (not a union with the previous type).

Adds a new binding for id. If a binding already existed, replaces its previous definitions, if any, with loc. Sets the binding's type to type (not a union with the previous type).