ni_nitdoc: added fast copy past utility to signatures.

[nit.git] / src / scope.nit

# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2012 Jean Privat <jean@pryen.org>
#
# 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.

# Identification and scping of local variables and labels.
module scope

import parser
import toolcontext
import phase

import modelbuilder #FIXME useless

redef class ToolContext
        var scope_phase: Phase = new ScopePhase(self, null)
end

private class ScopePhase
        super Phase
        redef fun process_npropdef(npropdef) do npropdef.do_scope(toolcontext)
end


# A local variable (including parameters, automatic variables and self)
class Variable
        # The name of the variable (as used in the program)
        var name: String

        # Alias of `name'
        redef fun to_s do return self.name
end

# A local variable associated to a closure definition
class ClosureVariable
        super Variable
end

# Mark where break and continue will branch.
# Marks are either associated with a label of with a for_loop structure
class EscapeMark
        # The name of the label (unless the mark is an anonymous loop mark)
        var name: nullable String

        # Is the mark atached to a loop (loop, while, for, closure)
        # Such a mark is a candidate to a labelless 'continue' or 'break'
        var for_loop: Bool

        # Each 'continue' attached to the mark
        var continues: Array[AContinueExpr] = new Array[AContinueExpr]

        # Each 'break' attached to the mark
        var breaks: Array[ABreakExpr] = new Array[ABreakExpr]
end

# Visit a npropdef and:
#  * Identify variables, closures and labels
#  * Associate each break and continue to its escapemark
#  * Transform ACallFormExpr that access a variable into AVarFormExpr
#  * Transform ACallFormExpr that call a closure into AClosureCallExpr
# FIXME: Should the class be private?
private class ScopeVisitor
        super Visitor

        # The tool context used to display errors
        var toolcontext: ToolContext

        var selfvariable: Variable = new Variable("self")

        init(toolcontext: ToolContext)
        do
                self.toolcontext = toolcontext
                scopes.add(new Scope)
        end

        # All stacked scope. `scopes.first' is the current scope
        private var scopes: List[Scope] = new List[Scope]

        # Regiter a local variable.
        # Display an error on toolcontext if a variable with the same name is masked.
        fun register_variable(node: ANode, variable: Variable): Bool
        do
                var name = variable.name
                var found = search_variable(name)
                if found != null then
                        self.error(node, "Error: A variable named `{name}' already exists")
                        return false
                end
                scopes.first.variables[name] = variable
                return true
        end

        # Look for a variable named `name'.
        # Return null if no such a variable is found.
        fun search_variable(name: String): nullable Variable
        do
                for scope in scopes do
                        var res = scope.get_variable(name)
                        if res != null then
                                return res
                        end
                end
                return null
        end

        redef fun visit(n: nullable ANode)
        do
                n.accept_scope_visitor(self)
        end

        # Enter in a statement block `node' as inside a new scope.
        # The block can be optionally attached to an `escapemark'.
        private fun enter_visit_block(node: nullable AExpr, escapemark: nullable EscapeMark)
        do
                if node == null then return
                var scope = new Scope
                scope.escapemark = escapemark
                scopes.unshift(scope)
                enter_visit(node)
                scopes.shift
        end

        # Look for a label `name'.
        # Return nulll if no such a label is found.
        private fun search_label(name: String): nullable EscapeMark
        do
                for scope in scopes do
                        var res = scope.escapemark
                        if res != null and res.name == name then
                                return res
                        end
                end
                return null
        end

        # Create a new escape mark (possibly with a label)
        # Display an error on toolcontext if a label with the same name is masked.
        private fun make_escape_mark(nlabel: nullable ALabel, for_loop: Bool): EscapeMark
        do
                assert named_or_for_loop: nlabel != null or for_loop
                var name: nullable String
                if nlabel != null then
                        name = nlabel.n_id.text
                        var found = self.search_label(name)
                        if found != null then
                                self.error(nlabel, "Syntax error: label {name} already defined.")
                        end
                else
                        name = null
                end
                var res = new EscapeMark(name, for_loop)
                return res
        end

        # Look for an escape mark optionally associated with a label.
        # If a label is given, the the escapemark of this label is returned.
        # If there is no label, the nearest escapemark that is `for loop' ir returned.
        # If there is no valid escapemark, then an error is displayed ans null is returned.
        # Return nulll if no such a label is found.
        private fun get_escapemark(node: ANode, nlabel: nullable ALabel): nullable EscapeMark
        do
                if nlabel != null then
                        var name = nlabel.n_id.text
                        var res = search_label(name)
                        if res == null then
                                self.error(nlabel, "Syntax error: invalid label {name}.")
                                return null
                        end
                        return res
                else
                        for scope in scopes do
                                var res = scope.escapemark
                                if res != null and res.for_loop then
                                        return res
                                end
                        end
                        self.error(node, "Syntax Error: 'break' statment outside block.")
                        return null
                end
        end

        # Display an error
        private fun error(node: ANode, message: String)
        do
                self.toolcontext.error(node.hot_location, message)
        end
end

private class Scope
        var variables: HashMap[String, Variable] = new HashMap[String, Variable]

        var escapemark: nullable EscapeMark = null

        fun get_variable(name: String): nullable Variable
        do
                if self.variables.has_key(name) then
                        return self.variables[name]
                else
                        return null
                end
        end
end

redef class ANode
        private fun accept_scope_visitor(v: ScopeVisitor)
        do
                visit_all(v)
        end
end

redef class APropdef
        # Entry point of the scope analysis
        fun do_scope(toolcontext: ToolContext)
        do
                var v = new ScopeVisitor(toolcontext)
                v.enter_visit(self)
        end
end

redef class AParam
        # The variable associated with the parameter
        var variable: nullable Variable
        redef fun accept_scope_visitor(v)
        do
                super
                var nid = self.n_id
                var variable = new Variable(nid.text)
                v.register_variable(nid, variable)
                self.variable = variable
        end
end

redef class AClosureDecl
        # The variable associated with the closure declaration
        var variable: nullable ClosureVariable
        redef fun accept_scope_visitor(v)
        do
                var nid = self.n_id
                var variable = new ClosureVariable(nid.text)
                v.register_variable(nid, variable)
                self.variable = variable
        end
end

redef class AVardeclExpr
        # The variable associated with the variable declaration
        var variable: nullable Variable
        redef fun accept_scope_visitor(v)
        do
                super
                var nid = self.n_id
                var variable = new Variable(nid.text)
                v.register_variable(nid, variable)
                self.variable = variable
        end
end

redef class ASelfExpr
        # The variable associated with the self reciever
        var variable: nullable Variable
        redef fun accept_scope_visitor(v)
        do
                super
                self.variable = v.selfvariable
        end
end

redef class AContinueExpr
        # The escape mark associated with the continue
        var escapemark: nullable EscapeMark
        redef fun accept_scope_visitor(v)
        do
                super
                var escapemark = v.get_escapemark(self, self.n_label)
                if escapemark == null then return # Skip error
                if not escapemark.for_loop then
                        v.error(self, "Error: cannot 'continue', only 'break'.")
                end
                escapemark.continues.add(self)
                self.escapemark = escapemark
        end
end

redef class ABreakExpr
        # The escape mark associated with the break
        var escapemark: nullable EscapeMark
        redef fun accept_scope_visitor(v)
        do
                super
                var escapemark = v.get_escapemark(self, self.n_label)
                if escapemark == null then return # Skip error
                escapemark.breaks.add(self)
                self.escapemark = escapemark
        end
end


redef class ADoExpr
        # The escape mark associated with the 'do' block
        var escapemark: nullable EscapeMark
        redef fun accept_scope_visitor(v)
        do
                if n_label != null then
                        self.escapemark = v.make_escape_mark(n_label, false)
                end
                v.enter_visit_block(n_block, self.escapemark)
        end
end

redef class AIfExpr
        redef fun accept_scope_visitor(v)
        do
                v.enter_visit(n_expr)
                v.enter_visit_block(n_then, null)
                v.enter_visit_block(n_else, null)
        end
end

redef class AWhileExpr
        # The escape mark associated with the 'while'
        var escapemark: nullable EscapeMark
        redef fun accept_scope_visitor(v)
        do
                var escapemark = v.make_escape_mark(n_label, true)
                self.escapemark = escapemark
                v.enter_visit(n_expr)
                v.enter_visit_block(n_block, escapemark)
        end
end

redef class ALoopExpr
        # The escape mark associated with the 'loop'
        var escapemark: nullable EscapeMark
        redef fun accept_scope_visitor(v)
        do
                var escapemark = v.make_escape_mark(n_label, true)
                self.escapemark = escapemark
                v.enter_visit_block(n_block, escapemark)
        end
end

redef class AForExpr
        # The automatic variables in order
        var variables: nullable Array[Variable]

        # The escape mark associated with the 'for'
        var escapemark: nullable EscapeMark

        redef fun accept_scope_visitor(v)
        do
                v.enter_visit(n_expr)

                # Protect automatic variables
                v.scopes.unshift(new Scope)

                # Create the automatic variables
                var variables = new Array[Variable]
                self.variables = variables
                for nid in n_ids do
                        var va = new Variable(nid.text)
                        v.register_variable(nid, va)
                        variables.add(va)
                end

                var escapemark = v.make_escape_mark(n_label, true)
                self.escapemark = escapemark
                v.enter_visit_block(n_block, escapemark)

                v.scopes.shift
        end
end

redef class AVarFormExpr
        # The associated variable
        var variable: nullable Variable
end

redef class ACallFormExpr
        redef fun accept_scope_visitor(v)
        do
                if n_expr isa AImplicitSelfExpr then
                        var name = n_id.text
                        var variable = v.search_variable(name)
                        if variable != null then
                                var n: AExpr
                                if variable isa ClosureVariable then
                                        n = new AClosureCallExpr.init_aclosurecallexpr(n_id, n_args, n_closure_defs)
                                        n.variable = variable
                                else
                                        if not n_args.n_exprs.is_empty or n_args isa AParExprs then
                                                v.error(self, "Error: {name} is variable, not a function.")
                                                return
                                        end
                                        n = variable_create(variable)
                                        n.variable = variable
                                end
                                replace_with(n)
                                n.accept_scope_visitor(v)
                                return
                        end
                end

                super
        end

        # Create a variable acces corresponding to the call form
        private fun variable_create(variable: Variable): AVarFormExpr is abstract
end

redef class ACallExpr
        redef fun variable_create(variable)
        do
                return new AVarExpr.init_avarexpr(n_id)
        end
end

redef class ACallAssignExpr
        redef fun variable_create(variable)
        do
                return new AVarAssignExpr.init_avarassignexpr(n_id, n_assign, n_value)
        end
end

redef class ACallReassignExpr
        redef fun variable_create(variable)
        do
                return new AVarReassignExpr.init_avarreassignexpr(n_id, n_assign_op, n_value)
        end
end

redef class AClosureCallExpr
        # the associate closure variable
        var variable: nullable ClosureVariable
end

redef class ASendExpr
        # The escape mark used with the closures if any
        var escapemark: nullable EscapeMark

        redef fun accept_scope_visitor(v)
        do
                if self.n_closure_defs.length > 0 then
                        var escapemark = v.make_escape_mark(self.n_closure_defs.last.n_label, true)
                        self.escapemark = escapemark
                end
                super
        end
end

redef class AClosureDef
        # The automatic variables in order
        var variables: nullable Array[Variable]

        # The escape mark used with the closure
        var escapemark: nullable EscapeMark

        redef fun accept_scope_visitor(v)
        do
                v.scopes.unshift(new Scope)

                var variables = new Array[Variable]
                self.variables = variables

                for nid in self.n_ids do
                        var va = new Variable(nid.text)
                        v.register_variable(nid, va)
                        variables.add(va)
                end

                self.escapemark = self.parent.as(ASendExpr).escapemark
                v.enter_visit_block(self.n_expr, escapemark)

                v.scopes.shift
        end
end