[nit.git] / contrib / jwrapper / src / javap_visitor.nit

# This file is part of NIT (http://www.nitlanguage.org).
#
# Copyright 2014 Frédéric Vachon <fredvac@gmail.com>
# Copyright 2015 Alexis Laferrière <alexis.laf@xymus.net>
#
# 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.

# Uses a visitor to extract data from the javap output AST
# It sends the data to `code_generator` module
module javap_visitor

import javap_test_parser
import code_generator
import jtype_converter
intrude import model

# Visitor of the AST generated from javap output
class JavaVisitor
        super Visitor

        # Model of all the analyzed classes
        var model: JavaModel

        # Java class in construction
        var java_class: JavaClass is noinit

        redef fun visit(n) do n.accept_visitor(self)
end

redef class Node
        private fun accept_visitor(v: JavaVisitor) do visit_children(v)
end

# ---
# Class Header

redef class Nclass_declaration
        redef fun accept_visitor(v)
        do
                var jtype = n_full_class_name.to_java_type

                v.java_class = new JavaClass(jtype)
                v.model.add_class v.java_class

                # Visit all properties
                super
        end
end

# Extends declaration in the class header
redef class Nextends_declaration
        redef fun accept_visitor(v)
        do
                # TODO
        end
end

# Implements declaration in the class header
redef class Nimplements_declaration
        redef fun accept_visitor(v)
        do
                # TODO
        end
end

# ---
# Properties

# Method declaration
redef class Nproperty_declaration_method
        redef fun accept_visitor(v)
        do
                var is_static = false
                var modifiers = n_modifier
                if modifiers != null then is_static = modifiers.has_static

                var id = n_identifier.text
                var return_jtype = n_type.to_java_type

                # Generic parameters
                var n_params = n_generic_parameters
                var generic_params
                if n_params != null then
                        generic_params = n_params.n_types.to_a
                else generic_params = new Array[JavaType]

                # Collect parameters
                var n_types = n_types
                var params
                if n_types != null then
                        params = n_types.to_a
                else params = new Array[JavaType]

                var method = new JavaMethod(is_static, return_jtype, params, generic_params)
                v.java_class.methods[id].add method
        end
end

# Constructor declaration
redef class Nproperty_declaration_constructor
        redef fun accept_visitor(v)
        do
                # Collect parameters
                var n_types = n_types
                var params
                if n_types != null then
                        params = n_types.to_a
                else params = new Array[JavaType]

                # Generic parameters
                var n_params = n_generic_parameters
                var generic_params
                if n_params != null then
                        generic_params = n_params.n_types.to_a
                else generic_params = new Array[JavaType]

                var method = new JavaConstructor(params, generic_params)
                v.java_class.constructors.add method
        end
end

# Variable property declaration
redef class Nproperty_declaration_attribute
        redef fun accept_visitor(v)
        do
                var id = n_identifier.text
                var jtype = n_type.to_java_type

                # Manually count the array depth as it is after the id
                var brackets = n_brackets
                if brackets != null then jtype.array_dimension += brackets.children.length

                var is_static = false
                var modifiers = n_modifier
                if modifiers != null then is_static = modifiers.has_static

                v.java_class.attributes[id] = new JavaAttribute(is_static, jtype)
        end
end

# Static property declaration
redef class Nproperty_declaration_static
        redef fun accept_visitor(v)
        do
                # TODO
        end
end

# ---
# Services

redef class Ntype
        private fun to_java_type: JavaType
        do
                var jtype = n_base_type.to_java_type

                var brackets = n_brackets
                if brackets != null then jtype.array_dimension += brackets.children.length

                var dots = n_dots
                if dots != null then jtype.is_vararg = true

                return jtype
        end
end

redef class Nbase_type
        private fun to_java_type: JavaType
        do
                # By default, everything is bound by object
                var jtype = new JavaType
                jtype.identifier.add_all(["java", "lang", "object"])
                return jtype
        end
end

redef class Nbase_type_class
        redef fun to_java_type do return n_full_class_name.to_java_type
end

redef class Nbase_type_primitive
        redef fun to_java_type
        do
                # All the concrete nodes under this production are tokens
                for node in depth do
                        if not node isa NToken then continue

                        var jtype = new JavaType
                        jtype.identifier.add node.text
                        return jtype
                end

                abort
        end
end

redef class Nbase_type_void
        redef fun to_java_type
        do
                var jtype = new JavaType
                jtype.is_void = true
                return jtype
        end
end

redef class Nbase_type_extends
        redef fun to_java_type do return n_generic_identifier.to_java_type
end

redef class Nbase_type_super
        redef fun to_java_type
        do
                var bounds = n_type_bound.to_a

                # Java use more than one lower bound,
                # it can't be translated statically to Nit,
                # so we use the only the first one.
                # This may cause problems on complex generic types,
                # but these cases can be handled manually.
                return bounds.first
        end
end

redef class Ngeneric_identifier
        private fun to_java_type: JavaType is abstract
end

redef class Ngeneric_identifier_class
        redef fun to_java_type do return n_full_class_name.to_java_type
end

redef class Ngeneric_identifier_wildcard
        redef fun to_java_type
        do
                var jtype = new JavaType
                jtype.identifier.add_all(["java", "lang", "Object"])
                return jtype
        end
end

redef class Nfull_class_name
        # All the identifiers composing this class name
        private fun to_a: Array[String] is abstract

        # Access `n_class_name` on both alternatives
        private fun n_class_name_common: Nclass_name is abstract

        private fun to_java_type: JavaType
        do
                var jtype = new JavaType
                jtype.identifier = to_a

                # Generic parameters
                var n_params = n_class_name_common.n_generic_parameters
                if n_params != null then jtype.generic_params = n_params.n_types.to_a

                return jtype
        end
end

redef class Nfull_class_name_head
        redef fun n_class_name_common do return n_class_name

        redef fun to_a do return [n_class_name.n_identifier.text]
end

redef class Nfull_class_name_tail
        redef fun n_class_name_common do return n_class_name

        redef fun to_a
        do
                var a = n_full_class_name.to_a
                a.add n_class_name.n_identifier.text
                return a
        end
end

redef class Ntypes
        # Get the types composing this list of parameters
        #
        # This is used both on methods signatures and type parameters.
        private fun to_a: Array[JavaType] is abstract
end

redef class Ntypes_head
        redef fun to_a do return [n_type.to_java_type]
end

redef class Ntypes_tail
        redef fun to_a
        do
                var a = n_types.to_a
                a.add n_type.to_java_type
                return a
        end
end

redef class Nodes
        private fun has_static: Bool
        do
                for modifier in depth do
                        if modifier isa NToken and modifier.text == "static" then return true
                end

                return false
        end
end

redef class Ntype_bound
        # Get the types composing this bound
        private fun to_a: Array[JavaType] is abstract
end

redef class Ntype_bound_head
        redef fun to_a do return [n_full_class_name.to_java_type]
end

redef class Ntype_bound_tail
        redef fun to_a
        do
                var a = n_type_bound.to_a
                a.add n_full_class_name.to_java_type
                return a
        end
end