The Fortress Language Specification - CiteSeerX

We first define a declaration’s reach. The reach of a labeled block is the block itself. A method declaration not in
an object expression or declaration must be in the declaration of some trait T , and its reach is the declaration of T
and any trait or object declarations or object expressions that extend T ; that is, if the declaration of trait T contains a
method declaration, and trait S extends trait T , then the reach of that method declaration includes the declaration of
trait S. The reach of any other declaration is the smallest block strictly containing that declaration (i.e., not just the
declaration itself). For example, the reach of a top-level declaration is the component containing that declaration, the
reach of a field declaration is the enclosing object declaration or expression, the reach of a parameter declaration is
the functional declaration or function expression in whose parameter list it occurs, and the reach of a local variable
declaration is the smallest block in which that declaration occurs. We say that a declaration reaches any point within
its reach.
It is a static error for two declarations with overlapping reaches to declare the same name other than self (even if the
name is declared in different namespaces) unless one of the following conditions holds:
• both declarations are functional declarations with the same reach,
• both declarations are method declarations that occur in different trait declarations,
• one declaration is a field or keyword-parameter declaration whose reach is strictly contained in the reach of the
other declaration, or
• one declaration is a method declaration that is provided by (i.e., occurs in or is inherited by) some trait or object
declaration or object expression that is strictly contained in the reach of the other declaration.
If either of the first two conditions holds, or if one declaration is a field or method declaration that occurs in an object
declaration or expression that inherits the other declaration (which therefore must be a method declaration), then the
two declarations are overloaded, and subject to the restrictions on overloading (see Chapter 33).
If two declarations with overlapping reaches declare the same name in the same namespace, and the declarations are
not overloaded, then at any point that their reaches overlap, one declaration shadows the other for that name in that
namespace; we may omit the name and namespace when it is clear from context. Shadowing is permitted only in the
following cases:
• In a trait or object declaration, any declaration in a block enclosing the declaration is shadowed if it declares a
name of a field or method provided (declared or inherited) by the trait or object being declared.
• In a method declaration that does not give an explicit name other than self for the self parameter, any declaration
of self (including implicit declarations) in a block enclosing the field or method declaration is shadowed.
• In the ensures clause of a contract, any declaration of result in a block enclosing the ensures clause is
shadowed.
• In a function or method declaration with keyword parameters, any declaration in a block enclosing the declaration
is shadowed if it declares the name of any of the keyword parameters.
We say that a name is in scope in a namespace at any point in the program within the reach of a declaration that
declares that name in that namespace unless one of the following conditions holds:
• the declaration is shadowed for the name in that namespace,
• the declaration is a variable declaration, the namespace is the value namespace, and the program point is in
the initial-value expression of the declaration or an initial-value expression of another declaration that is in the
smallest lexical block enclosing the declaration and lexically precedes the declaration in that block.
Note that the last condition applies to the method names declared by a wrapped field declaration.
We say that the scope of a declaration for a name in a namespace consists of those points at which the name is in scope
for the namespace and the declaration is not shadowed for that name and that namespace. Again, when it is clear from
context, we may omit the name and namespace.
62