mirah 0.0.12-java → 0.1.0-java

data/lib/mirah/ast/call.rb

@@ -1,345 +0,0 @@
-# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
-# All contributing project authors may be found in the NOTICE file.
-#
-# 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.
-
-module Mirah::AST
-  class FunctionalCall < Node
-    include Java::DubyLangCompiler.Call
-    include Named
-    include Scoped
-    attr_accessor :cast, :inlined, :proxy
-    alias cast? cast
-
-    child :parameters
-    child :block
-
-    def self.new(*args, &block)
-      real_node = super
-      real_node.proxy = NodeProxy.new(real_node)
-    end
-
-    def initialize(parent, line_number, name, &kids)
-      super(parent, line_number, &kids)
-      self.name = name
-      @cast = false
-    end
-
-    def arguments
-      args = java.util.ArrayList.new(parameters.size)
-      parameters.each do |param|
-        args.add(param)
-      end
-      args
-    end
-
-    def target
-      nil
-    end
-
-    def validate_parameters
-      parameters.each_with_index do |child, i|
-        if UnquotedValue === child
-          children = child.nodes
-          children.each {|c| c.parent = self}
-          parameters[i] = children
-        end
-      end
-      parameters.flatten!
-    end
-
-    def infer(typer, expression)
-      unless @inferred_type
-        @self_type ||= scope.static_scope.self_type
-        receiver_type = @self_type
-        should_defer = false
-
-        parameter_types = parameters.map do |param|
-          typer.infer(param, true) || should_defer = true
-        end
-
-        parameter_types << Mirah::AST.block_type if block
-
-        unless should_defer
-          if parameters.size == 1 && typer.known_type(scope, name)
-            # cast operation
-            resolved!
-            self.cast = true
-            @inferred_type = typer.known_type(scope, name)
-          elsif parameters.size == 0 && scope.static_scope.include?(name)
-            @inlined = Local.new(parent, position, name)
-            proxy.__inline__(@inlined)
-            return proxy.infer(typer, expression)
-          else
-            @inferred_type = typer.method_type(receiver_type, name,
-                                               parameter_types)
-            if @inferred_type.kind_of? InlineCode
-              @inlined = @inferred_type.inline(typer.transformer, self)
-              proxy.__inline__(@inlined)
-              return proxy.infer(typer, expression)
-            end
-          end
-        end
-
-        if @inferred_type && !@inferred_type.error?
-          if block
-            method = receiver_type.get_method(name, parameter_types)
-            block.prepare(typer, method)
-          end
-          @inferred_type = receiver_type if @inferred_type.void?
-          resolved!
-        else
-          if should_defer || receiver_type.nil?
-            message = nil
-          else
-            parameter_names = parameter_types.map {|t| t.full_name}.join(', ')
-            receiver = receiver_type.full_name
-            desc = "#{name}(#{parameter_names})"
-            kind = receiver_type.meta? ? "static" : "instance"
-            message = "Cannot find #{kind} method #{desc} on #{receiver}"
-          end
-          typer.defer(proxy, message)
-        end
-      end
-
-      @inferred_type
-    end
-
-    def type_reference(typer)
-      typer.type_reference(scope, name)
-    end
-  end
-
-  class Call < Node
-    include Java::DubyLangCompiler.Call
-    include Named
-    include Scoped
-    attr_accessor :cast, :inlined, :proxy
-    alias cast? cast
-
-    child :target
-    child :parameters
-    child :block
-
-    def self.new(*args, &block)
-      real_node = super
-      real_node.proxy = NodeProxy.new(real_node)
-    end
-
-    def initialize(parent, line_number, name, &kids)
-      super(parent, line_number, &kids)
-      self.name = name
-    end
-
-    def validate_parameters
-      parameters.each_with_index do |child, i|
-        if UnquotedValue === child
-          child = child.node
-          child.parent = self
-          parameters[i] = child
-        end
-      end
-    end
-
-    def arguments
-      args = java.util.ArrayList.new(parameters.size)
-      parameters.each do |param|
-        args.add(param)
-      end
-      args
-    end
-
-    def infer(typer, expression)
-      unless @inferred_type
-        receiver_type = typer.infer(target, true)
-        should_defer = receiver_type.nil?
-        parameter_types = parameters.map do |param|
-          typer.infer(param, true) || should_defer = true
-        end
-
-        parameter_types << Mirah::AST.block_type if block
-
-        unless should_defer
-          class_name, array = self.type_name(true)
-          if class_name && parameters.size == 1 && typer.known_type(scope, class_name)
-            # Support casts to fully-qualified names and inner classes.
-            begin
-              type = inferred_type = typer.type_reference(scope, class_name, array)
-              @inferred_type = type unless (type && type.error?)
-              if @inferred_type
-                # cast operation
-                resolved!
-                self.cast = true
-                return @inferred_type
-              end
-            rescue
-            end
-          end
-          @inferred_type = typer.method_type(receiver_type, name,
-                                             parameter_types)
-          if @inferred_type.kind_of? InlineCode
-            @inlined = @inferred_type.inline(typer.transformer, self)
-            proxy.__inline__(@inlined)
-            return proxy.infer(typer, expression)
-          end
-        end
-
-        if @inferred_type
-          if block && !receiver_type.error?
-            method = receiver_type.get_method(name, parameter_types)
-            block.prepare(typer, method)
-          end
-          @inferred_type = receiver_type if @inferred_type.void?
-          resolved!
-        else
-          if should_defer
-            message = nil
-          else
-            parameter_names = parameter_types.map {|t| t.full_name}.join(', ')
-            receiver = receiver_type.full_name
-            desc = "#{name}(#{parameter_names})"
-            kind = receiver_type.meta? ? "static" : "instance"
-            message = "Cannot find #{kind} method #{desc} on #{receiver}"
-          end
-          typer.defer(proxy, message)
-        end
-      end
-
-      @inferred_type
-    end
-
-    def type_reference(typer)
-      class_name, array = type_name
-      typer.type_reference(scope, class_name, array)
-    end
-
-    def type_name(force=false)
-      if !force && parameters && !parameters.empty?
-        return nil
-      end
-      if name == "[]"
-        # array type, top should be a constant; find the rest
-        array = true
-        elements = []
-      else
-        array = false
-        elements = [name]
-      end
-      old_receiver = nil
-      receiver = self.target
-      while !receiver.eql?(old_receiver)
-        old_receiver = receiver
-        case receiver
-        when Constant, Local, Annotation
-          elements.unshift(receiver.name)
-        when FunctionalCall
-          if receiver.parameters.nil? || receiver.parameters.empty?
-            elements.unshift(receiver.name)
-          else
-            return nil, nil
-          end
-        when Call
-          if receiver.parameters.nil? || receiver.parameters.empty?
-            elements.unshift(receiver.name)
-            receiver = receiver.target
-          else
-            return nil, nil
-          end
-        when String
-          elements.unshift(receiver.literal)
-        end
-      end
-
-      return elements.join("."), array
-    end
-  end
-
-
-  class Colon2 < Call
-    def infer(typer, expression)
-      resolve_if(typer) do
-        type_reference(typer).meta
-      end
-    end
-  end
-
-  class Super < Node
-    include Named
-    include Scoped
-    attr_accessor :method, :cast
-    alias :cast? :cast
-
-    child :parameters
-
-    def initialize(parent, line_number)
-      super(parent, line_number)
-      @cast = false
-    end
-
-    def call_parent
-      @call_parent ||= begin
-        node = parent
-        node = (node && node.parent) until MethodDefinition === node
-        node
-      end
-    end
-
-    def name
-      call_parent.name
-    end
-
-    def infer(typer, expression)
-      @self_type ||= scope.static_scope.self_type.superclass
-
-      unless @inferred_type
-        receiver_type = call_parent.defining_class.superclass
-        should_defer = receiver_type.nil?
-        parameter_types = parameters.map do |param|
-          typer.infer(param, true) || should_defer = true
-        end
-
-        unless should_defer
-          @inferred_type = typer.method_type(receiver_type, name,
-                                             parameter_types)
-        end
-
-        @inferred_type ? resolved! : typer.defer(self)
-      end
-
-      @inferred_type
-    end
-
-    alias originial_parameters parameters
-
-    def parameters
-      if originial_parameters.nil?
-        self.parameters = default_parameters
-      end
-      originial_parameters
-    end
-
-    def default_parameters
-      node = self
-      node = node.parent until MethodDefinition === node || node.nil?
-      return [] if node.nil?
-      args = node.arguments.children.map {|x| x || []}
-      args.flatten.map do |arg|
-        Local.new(self, position, arg.name)
-      end
-    end
-  end
-
-  class BlockPass < Node
-    child :value
-  end
-end

data/lib/mirah/ast/class.rb

@@ -1,359 +0,0 @@
-# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
-# All contributing project authors may be found in the NOTICE file.
-#
-# 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.
-
-module Mirah::AST
-  class ClassDefinition < Node
-    include Annotated
-    include Named
-    include Scope
-    include Java::DubyLangCompiler.ClassDefinition
-
-    attr_accessor :interfaces
-    attr_accessor :current_access_level
-    attr_accessor :abstract
-
-    child :superclass_node
-    child :body
-
-    attr_accessor :superclass
-
-    def initialize(parent, position, name, annotations=[], &block)
-      @abstract = false
-      @annotations = annotations
-      @interfaces = []
-      @interface_nodes = []
-      self.name = name
-      self.parent = parent
-      if Mirah::AST.type_factory.respond_to? :define_type
-        Mirah::AST.type_factory.define_type(self)
-      end
-      # We need somewhere to collect nodes that get appended during
-      # the transform phase.
-      @extra_body = Body.new(self, position)
-      super(parent, position, &block)
-      if body
-        @extra_body.insert(0, body)
-      end
-      self.body = @extra_body
-    end
-
-    def append_node(node)
-      @extra_body << node
-      node
-    end
-
-    def define_method(position, name, type, *args, &block)
-      append_node(_define_method(MethodDefinition, position, name, type, args, &block))
-    end
-
-    def define_static_method(position, name, type, *args, &block)
-      append_node(
-          _define_method(StaticMethodDefinition, position, name, type, args, &block))
-    end
-
-    def define_constructor(position, *args, &block)
-      append_node(_define_method(
-          ConstructorDefinition, position, 'initialize', nil, args, &block))
-    end
-
-    def _define_method(klass, position, name, type, args)
-      klass.new(nil, position, name) do |method|
-        signature = {:return => type}
-        if Arguments === args[0]
-          args_node = args[0]
-          args_node.parent = method
-        else
-          args_node = Arguments.new(method, position) do |args_node|
-            arg_list = args.map do |arg_name, arg_type, arg_position|
-              signature[arg_name.intern] = arg_type
-              arg_position ||= position
-              RequiredArgument.new(args_node, arg_position, arg_name)
-            end
-            [arg_list, nil, nil, nil]
-          end
-        end
-        [
-          signature,
-          args_node,
-          if block_given?
-            yield(method)
-          end
-        ]
-      end
-    end
-
-    def declare_field(position, name, type)
-      field = FieldDeclaration.new(nil, position || self.position, name)
-      field.type = type.dup
-      append_node(field)
-    end
-
-    def infer(typer, expression)
-      resolve_if(typer) do
-        @superclass = superclass_node.type_reference(typer) if superclass_node
-        @annotations.each {|a| a.infer(typer, true)} if @annotations
-        @interfaces.concat(@interface_nodes.map{|n| n.type_reference(typer)})
-        typer.define_type(self, name, superclass, @interfaces) do
-          static_scope.self_type = typer.self_type
-          typer.infer(body, false) if body
-        end
-      end
-    end
-
-    def implements(*types)
-      raise ArgumentError if types.any? {|x| x.nil?}
-      types.each do |type|
-        if Mirah::AST::TypeReference === type
-          @interfaces << type
-        else
-          @interface_nodes << type
-        end
-      end
-    end
-
-    def top_level?
-      true
-    end
-  end
-
-  class Implements < Node
-    def infer(typer, expression)
-      resolve_if(typer) do
-        klass = parent
-        klass = klass.parent until ClassDefinition === klass
-        interfaces = children.map {|i| i.type_reference(typer) }
-        klass.implements(*interfaces)
-        typer.no_type
-      end
-    end
-    def compile(*args)
-    end
-  end
-
-  defmacro('implements') do |transformer, fcall, parent|
-    Implements.new(fcall.parent, fcall.position) do |node|
-      fcall.parameters.map {|i| i.parent = node; i}
-    end
-  end
-
-  class InterfaceDeclaration < ClassDefinition
-    attr_accessor :superclass, :interfaces
-    child :interface_nodes
-    child :body
-
-    def initialize(parent, position, name, annotations)
-      super(parent, position, name, annotations) {|p| }
-      @abstract = true
-      self.name = name
-      @children = [[], nil]
-      @children = yield(self)
-    end
-
-    def infer(typer, expression)
-      resolve_if(typer) do
-        @interfaces = interface_nodes.map {|i| i.type_reference(typer)}
-        super
-      end
-    end
-
-    def superclass_node
-      nil
-    end
-
-    def top_level?
-      true
-    end
-  end
-
-  class ClosureDefinition < ClassDefinition
-    attr_accessor :enclosing_type
-    def initialize(parent, position, name, enclosing_type)
-      super(parent, position, name, []) do
-        [nil, nil]
-      end
-      @enclosing_type = enclosing_type
-    end
-  end
-
-  defmacro('interface') do |transformer, fcall, parent|
-    raise Mirah::SyntaxError.new("Interface name required", fcall) unless fcall.parameters.size > 0
-    interfaces = fcall.parameters
-    interface_name = interfaces.shift
-    if (Call === interface_name &&
-        interface_name.parameters.size == 1)
-      interfaces.unshift(interface_name.parameters[0])
-      interface_name = interface_name.target
-    end
-    raise 'Interface body required' unless fcall.block
-    InterfaceDeclaration.new(parent, fcall.position,
-                             interface_name.name,
-                             transformer.annotations) do |interface|
-      interfaces.each {|x| x.parent = interface}
-      [interfaces,
-       if fcall.block.body
-         fcall.block.body.parent = interface
-         fcall.block.body
-       end
-      ]
-    end
-  end
-
-  class FieldDeclaration < Node
-    include Annotated
-    include Named
-    include ClassScoped
-    include Typed
-
-    child :type_node
-    attr_accessor :type
-    attr_accessor :static
-
-    def initialize(parent, position, name, annotations=[], static = false, &block)
-      @annotations = annotations
-      super(parent, position, &block)
-      self.name = name
-      @static = static
-    end
-
-    def infer(typer, expression)
-      resolve_if(typer) do
-        @annotations.each {|a| a.infer(typer, true)} if @annotations
-        @type = type_node.type_reference(typer)
-      end
-    end
-
-    def resolved!(typer)
-      if static
-        typer.learn_static_field_type(class_scope, name, @inferred_type)
-      else
-        typer.learn_field_type(class_scope, name, @inferred_type)
-      end
-      super
-    end
-  end
-
-  class FieldAssignment < Node
-    include Annotated
-    include Named
-    include Valued
-    include ClassScoped
-
-    child :value
-    attr_accessor :static
-
-    def initialize(parent, position, name, annotations=[], static = false, &block)
-      @annotations = annotations
-      super(parent, position, &block)
-      self.name = name
-      @static = static
-    end
-
-    def infer(typer, expression)
-      resolve_if(typer) do
-        @annotations.each {|a| a.infer(typer, true)} if @annotations
-        if static
-          typer.learn_static_field_type(class_scope, name, typer.infer(value, true))
-        else
-          typer.learn_field_type(class_scope, name, typer.infer(value, true))
-        end
-      end
-    end
-  end
-
-  class Field < Node
-    include Annotated
-    include Named
-    include ClassScoped
-    
-    attr_accessor :static
-
-    def initialize(parent, position, name, annotations=[], static = false, &block)
-      @annotations = annotations
-      super(parent, position, &block)
-      self.name = name
-      @static = static
-    end
-
-    def infer(typer, expression)
-      resolve_if(typer) do
-        @annotations.each {|a| a.infer(typer, true)} if @annotations
-        if static
-          typer.static_field_type(class_scope, name)
-        else
-          typer.field_type(class_scope, name)
-        end
-      end
-    end
-  end
-
-  class AccessLevel < Node
-    include ClassScoped
-    include Named
-
-    def initialize(parent, line_number, name)
-      super(parent, line_number)
-      self.name = name
-      class_scope.current_access_level = name.to_sym
-    end
-
-    def infer(typer, expression)
-      typer.no_type
-    end
-  end
-
-  class Include < Node
-    include Scoped
-
-    def infer(typer, expression)
-      children.each do |type|
-        typeref = type.type_reference(typer)
-        the_scope = scope.static_scope
-        the_scope.self_type = the_scope.self_type.include(typeref)
-      end
-    end
-  end
-
-  defmacro("include") do |transformer, fcall, parent|
-    raise "Included Class name required" unless fcall.parameters.size > 0
-    Include.new(parent, fcall.position) do |include_node|
-      fcall.parameters.map do |constant|
-        constant.parent = include_node
-        constant
-      end
-    end
-  end
-
-  class Constant < Node
-    include Named
-    include Scoped
-    attr_accessor :array
-
-    def initialize(parent, position, name)
-      self.name = name
-      super(parent, position, [])
-    end
-
-    def infer(typer, expression)
-      @inferred_type ||= begin
-        # TODO lookup constant, inline if we're supposed to.
-        typer.type_reference(scope, name, @array, true)
-      end
-    end
-
-    def type_reference(typer)
-      typer.type_reference(scope, @name, @array)
-    end
-  end
-end