mirah 0.0.4-java

data/lib/mirah/appengine_tasks.rb

@@ -0,0 +1,146 @@
+require 'appengine-sdk'
+require 'mirah_task'
+require 'java'
+require 'open-uri'
+require 'rake'
+require 'yaml'
+
+module AppEngine::Rake
+  SERVLET = AppEngine::SDK::SDK_ROOT +
+            '/lib/shared/geronimo-servlet_2.5_spec-1.2.jar'
+  APIS = AppEngine::SDK::API_JAR
+  TOOLS = AppEngine::SDK::TOOLS_JAR
+
+  $CLASSPATH << SERVLET
+  $CLASSPATH << APIS
+  $CLASSPATH << TOOLS
+
+  class AppEngineTask < Rake::Task
+    def initialize(*args, &block)
+      super
+      AppEngineTask.tasks << self
+    end
+
+    def init(src, war)
+      @src = src
+      @war = war
+      unless $CLASSPATH.include?(webinf_classes)
+        $CLASSPATH << webinf_classes
+      end
+      webinf_lib_jars.each do |jar|
+        $CLASSPATH << jar unless $CLASSPATH.include?(jar)
+      end
+      Duby.source_paths << src
+      Duby.dest_paths << webinf_classes
+      directory(webinf_classes)
+      directory(webinf_lib)
+
+      file_create api_jar => webinf_lib do
+        puts 'Coping apis'
+        cp APIS, api_jar
+      end
+
+      task :server => [name] do
+        check_for_updates
+        args = [
+          'java', '-cp', TOOLS,
+          'com.google.appengine.tools.KickStart',
+          'com.google.appengine.tools.development.DevAppServerMain',
+          @war
+        ]
+        system *args
+        @done = true
+        @update_thread.join
+      end
+      task :upload => [name] do
+        Java::ComGoogleAppengineTools::AppCfg.main(
+            ['update', @war].to_java(:string))
+      end
+
+      enhance([api_jar])
+    end
+
+    def real_prerequisites
+      prerequisites.map {|n| application[n, scope]}
+    end
+
+    def check_for_updates
+      @update_thread = Thread.new do
+        # Give the server time to start
+        next_time = Time.now + 5
+        until @done
+          sleep_time = next_time - Time.now
+          sleep(sleep_time) if sleep_time > 0
+          next_time = Time.now + 1
+          update
+        end
+      end
+    end
+
+    def update
+      begin
+        timestamp = app_yaml_timestamp
+        @last_app_yaml_timestamp ||= timestamp
+        updated = false
+        real_prerequisites.each do |dep|
+          if dep.needed?
+            puts "Executing #{dep.name}"
+            dep.execute
+            updated = true
+          end
+        end
+        if updated || (timestamp != @last_app_yaml_timestamp)
+          begin
+            open('http://localhost:8080/_ah/reloadwebapp')
+            @last_app_yaml_timestamp = timestamp
+          rescue OpenURI::HTTPError
+          end
+        end
+      rescue Exception
+        puts $!, $@
+      end
+    end
+
+    def app_yaml_timestamp
+      if File.exist?(app_yaml)
+        File.mtime(app_yaml)
+      end
+    end
+
+    def app_yaml
+      @war + '/app.yaml'
+    end
+
+    def webinf_classes
+      @war + '/WEB-INF/classes'
+    end
+
+    def webinf_lib
+      @war + '/WEB-INF/lib'
+    end
+
+    def api_jar
+      File.join(webinf_lib, File.basename(APIS))
+    end
+
+    def webinf_lib_jars
+      Dir.glob(webinf_lib + '/*.jar')
+    end
+  end
+end
+
+def appengine_app(*args, &block)
+  deps = []
+  if args[-1].kind_of?(Hash)
+    hash = args.pop
+    arg = hash.keys[0]
+    deps = hash[arg]
+    args << arg
+  end
+  name, src, war = args
+  task = AppEngine::Rake::AppEngineTask.define_task(name => deps, &block)
+  src = File.expand_path(src || 'src')
+  war = File.expand_path(war || 'war')
+  task.init(src, war)
+  task
+end

data/lib/mirah/ast.rb

@@ -0,0 +1,615 @@
+require 'mirah/transform'
+require 'mirah/ast/scope'
+
+module Duby
+  module AST
+    class << self
+      attr_accessor :verbose
+    end
+
+    # The top of the AST class hierarchy, this represents an abstract AST node.
+    # It provides accessors for _children_, an array of all child nodes,
+    # _parent_, a reference to this node's parent (nil if none), and _newline_,
+    # whether this node represents a new line.
+    class Node
+      include Java::DubyLangCompiler.Node
+      include Enumerable
+
+      attr_accessor :children
+      attr_accessor :parent
+      attr_accessor :position
+      attr_accessor :newline
+      attr_accessor :inferred_type
+
+      def self.child(name)
+        @children ||= []
+        index = @children.size
+        class_eval <<-EOF
+          def #{name}
+            @children[#{index}]
+          end
+
+          def #{name}=(node)
+            @children[#{index}] = _set_parent(node)
+          end
+        EOF
+        @children << name
+      end
+
+      def self.child_name(i)
+        @children[i] if @children
+      end
+
+      def child_nodes
+        java.util.ArrayList.new(@children)
+      end
+
+      def initialize(parent, position, children = [])
+        JRuby.reference(self.class).setRubyClassAllocator(JRuby.reference(self.class).reified_class)
+        unless parent.nil? || Duby::AST::Node === parent
+          raise "Duby::AST::Node.new parent #{parent.class} must be nil or === Duby::AST::Node."
+        end
+
+        @parent = parent
+        @newline = false
+        @inferred_type = nil
+        @resolved = false
+        @position = position
+        if block_given?
+          @children ||= []
+          @children = yield(self) || []
+        else
+          @children = children
+        end
+      end
+
+      def _dump(depth)
+        to_skip = %w(@parent @newline @inferred_type @resolved @proxy @scope @class_scope @typer)
+        vars = {}
+        instance_variables.each do |name|
+          next if to_skip.include?(name)
+          vars[name] = instance_variable_get(name)
+          begin
+            Marshal.dump(vars[name]) if AST.verbose
+          rescue
+            puts "#{self}: Failed to marshal #{name}"
+            puts $!, $@
+            raise $!
+          end
+        end
+        Marshal.dump(vars)
+      end
+
+      def self._load(vars)
+        node = self.allocate
+        Marshal.load(vars).each do |name, value|
+          node.instance_variable_set(name, value)
+        end
+        node.children.each do |child|
+          node._set_parent(child)
+        end
+        node.validate_children
+        node
+      end
+
+      def validate_children
+        validate_name if respond_to?(:validate_name)
+        children.each_with_index do |child, i|
+          validate_child(child, i)
+        end
+      end
+
+      def validate_child(child, i)
+        name = self.class.child_name(i)
+        validator = :"validate_#{name}"
+        if name && respond_to?(validator)
+          send validator
+        else
+          if UnquotedValue === child
+            self[i] = child.node
+          end
+        end
+      end
+
+      def line_number
+        if @position
+          @position.start_line + 1
+        else
+          0
+        end
+      end
+
+      def log(message)
+        puts "* [AST] [#{simple_name}] " + message if AST.verbose
+      end
+
+      def inspect_children(indent = 0)
+        indent_str = ' ' * indent
+        str = ''
+        children.each_with_index do |child, i|
+          extra_indent = 0
+          if child
+            name = self.class.child_name(i)
+            if Duby::AST.verbose && name
+              str << "\n#{indent_str} #{name}:"
+              extra_indent = 1
+            end
+            if ::Array === child
+              child.each {|ary_child|
+                if Duby::AST.verbose && Node === ary_child && ary_child.parent != self
+                   str << "\n#{indent_str} (wrong parent)"
+                 end
+                str << "\n#{ary_child.inspect(indent + extra_indent + 1)}"
+              }
+            elsif ::Hash === child
+              str << "\n#{indent_str} #{child.inspect}"
+            else
+              if Duby::AST.verbose && Node === child && child.parent != self
+                str << "\n#{indent_str} (wrong parent)"
+              end
+              str << "\n#{child.inspect(indent + extra_indent + 1)}"
+            end
+          end
+        end
+        str
+      end
+
+      def inspect(indent = 0)
+        indent_str = ' ' * indent
+        indent_str << to_s << inspect_children(indent)
+      end
+
+      def simple_name
+        self.class.name.split("::")[-1]
+      end
+
+      def to_s; simple_name; end
+
+      def [](index) children[index] end
+
+      def []=(index, node)
+        node.parent = self
+        @children[index] = node
+      end
+
+      def each(&b) children.each(&b) end
+
+      def <<(node)
+        @children << _set_parent(node)
+        self
+      end
+
+      def insert(index, node)
+        node.parent = self
+        @children.insert(index, node)
+      end
+
+      def empty?
+        @children.empty?
+      end
+
+      def resolved!(typer=nil)
+        log "#{to_s} resolved!"
+        @resolved = true
+      end
+
+      def resolved?; @resolved end
+
+      def resolve_if(typer)
+        unless resolved?
+          @inferred_type = yield
+          @inferred_type ? resolved!(typer) : typer.defer(self)
+        end
+        @inferred_type
+      end
+
+      def self.===(other)
+        super || (other.kind_of?(NodeProxy) && (self === other.__getobj__))
+      end
+
+      def _set_parent(node)
+        case node
+        when Node
+          node.parent = self
+        when ::Array
+          node.each {|x| x.parent = self if x}
+        end
+        node
+      end
+
+      def initialize_copy(other)
+        @parent = nil
+        @children = []
+        other.children.each do |child|
+          case child
+          when ::Array
+            self << child.map {|x| x.dup}
+          when nil
+            self << nil
+          else
+            self << child.dup
+          end
+        end
+      end
+
+      def inferred_type!
+        unless @inferred_type
+          raise Duby::Typer::InferenceError.new(
+              "Internal Error: #{self.class} never inferred", self)
+        end
+        inferred_type
+      end
+    end
+
+
+    class ErrorNode < Node
+      def initialize(parent, error)
+        super(parent, error.position)
+        @error = error
+        @inferred_type = TypeReference::ErrorType
+        @resolved = true
+      end
+
+      def infer(typer)
+      end
+    end
+
+    module Named
+      attr_accessor :name
+
+      def to_s
+        "#{super}(#{name})"
+      end
+
+      def validate_name
+        if UnquotedValue === @name
+          @name = @name.name
+        end
+      end
+    end
+
+    module Typed
+      attr_accessor :type
+    end
+
+    module Valued
+      include Typed
+      attr_accessor :value
+    end
+
+    module Literal
+      include Typed
+      attr_accessor :literal
+
+      def to_s
+        "#{super}(#{literal.inspect})"
+      end
+    end
+
+    module Annotated
+      attr_accessor :annotations
+
+      def annotation(name)
+        name = name.to_s
+        annotations.find {|a| a.name == name}
+      end
+    end
+
+    module Binding
+      def binding_type(duby=nil)
+        static_scope.binding_type(defining_class, duby)
+      end
+
+      def binding_type=(type)
+        static_scope.binding_type = type
+      end
+
+      def has_binding?
+        static_scope.has_binding?
+      end
+    end
+
+    class Colon2 < Node; end
+
+    class Constant < Node
+      include Named
+      include Scoped
+      attr_accessor :array
+
+      def initialize(parent, position, name)
+        @name = name
+        super(parent, position, [])
+      end
+
+      def infer(typer)
+        @inferred_type ||= begin
+          # TODO lookup constant, inline if we're supposed to.
+          begin
+            typer.type_reference(scope, name, @array, true)
+          rescue NameError => ex
+            typer.known_types[@name] = Duby::AST.error_type
+            raise ex
+          end
+        end
+      end
+
+      def type_reference(typer)
+        begin
+          typer.type_reference(scope, @name, @array)
+        rescue NameError => ex
+          typer.known_types[@name] = Duby::AST.error_type
+          raise ex
+        end
+      end
+    end
+
+    class Self < Node
+      include Scoped
+      def infer(typer)
+        @inferred_type ||= scope.static_scope.self_type
+      end
+    end
+
+    class Annotation < Node
+      attr_reader :values
+      attr_accessor :runtime
+      alias runtime? runtime
+
+      child :name_node
+
+      def initialize(parent, position, name=nil, &block)
+        super(parent, position, &block)
+        if name
+          @name = if name.respond_to?(:class_name)
+            name.class_name
+          else
+            name.name
+          end
+        end
+        @values = {}
+      end
+
+      def name
+        @name
+      end
+
+      def type
+        BiteScript::ASM::Type.getObjectType(@name.tr('.', '/'))
+      end
+
+      def []=(name, value)
+        @values[name] = value
+      end
+
+      def [](name)
+        @values[name]
+      end
+
+      def infer(typer)
+        @inferred ||= begin
+          @name = name_node.type_reference(typer).name if name_node
+          @values.each do |name, value|
+            if Node === value
+              @values[name] = annotation_value(value, typer)
+            end
+          end
+          true
+        end
+      end
+
+      def annotation_value(node, typer)
+        case node
+        when String
+          java.lang.String.new(node.literal)
+        when Array
+          node.children.map {|node| annotation_value(node, typer)}
+        else
+          # TODO Support other types
+          ref = value.type_refence(typer)
+          desc = BiteScript::Signature.class_id(ref)
+          BiteScript::ASM::Type.getType(desc)
+        end
+      end
+    end
+
+    class TypeReference < Node
+      include Named
+      attr_accessor :array
+      alias array? array
+      attr_accessor :meta
+      alias meta? meta
+
+      def initialize(name, array = false, meta = false, position=nil)
+        super(nil, position)
+        @name = name
+        @array = array
+        @meta = meta
+      end
+
+      def type_reference(typer)
+        typer.type_reference(nil, name, array, meta)
+      end
+
+      def to_s
+        "Type(#{name}#{array? ? ' array' : ''}#{meta? ? ' meta' : ''})"
+      end
+
+      def full_name
+        "#{name}#{array ? '[]' : ''}"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        to_s.hash
+      end
+
+      def is_parent(other)
+        # default behavior now is to disallow any polymorphic types
+        self == other
+      end
+
+      def compatible?(other)
+        # default behavior is only exact match right now
+        self == other ||
+            error? || other.error? ||
+            unreachable? || other.unreachable?
+      end
+
+      def iterable?
+        array?
+      end
+
+      def component_type
+        AST.type(nil, name) if array?
+      end
+
+      def basic_type
+        if array? || meta?
+          TypeReference.new(name, false, false)
+        else
+          self
+        end
+      end
+
+      def narrow(other)
+        # only exact match allowed for now, so narrowing is a noop
+        if error? || unreachable?
+          other
+        else
+          self
+        end
+      end
+
+      def unmeta
+        TypeReference.new(name, array, false)
+      end
+
+      def meta
+        TypeReference.new(name, array, true)
+      end
+
+      def void?
+        name == :void
+      end
+
+      def error?
+        name == :error
+      end
+
+      def null?
+        name == :null
+      end
+
+      def unreachable?
+        name == :unreachable
+      end
+
+      def block?
+        name == :block
+      end
+
+      def primitive?
+        true
+      end
+
+      def _dump(depth)
+        Marshal.dump([name, array?, meta?])
+      end
+
+      def self._load(str)
+        AST::Type(*Marshal.load(str))
+      end
+
+      NoType = TypeReference.new(:notype)
+      NullType = TypeReference.new(:null)
+      ErrorType = TypeReference.new(:error)
+      UnreachableType = TypeReference.new(:unreachable)
+      BlockType = TypeReference.new(:block)
+    end
+
+    class TypeDefinition < TypeReference
+      attr_accessor :superclass, :interfaces
+
+      def initialize(name, superclass, interfaces)
+        super(name, false)
+
+        @superclass = superclass
+        @interfaces = interfaces
+      end
+    end
+
+    def self.type_factory
+      Thread.current[:ast_type_factory]
+    end
+
+    def self.type_factory=(factory)
+      Thread.current[:ast_type_factory] = factory
+    end
+
+    # Shortcut method to construct type references
+    def self.type(scope, typesym, array = false, meta = false)
+      factory = type_factory
+      if factory
+        factory.type(scope, typesym, array, meta)
+      else
+        TypeReference.new(typesym, array, meta)
+      end
+    end
+
+    def self.no_type
+      factory = type_factory
+      if factory
+        factory.no_type
+      else
+        TypeReference::NoType
+      end
+    end
+
+    def self.error_type
+      TypeReference::ErrorType
+    end
+
+    def self.unreachable_type
+      TypeReference::UnreachableType
+    end
+
+    def self.block_type
+      TypeReference::BlockType
+    end
+
+    def self.fixnum(parent, position, literal)
+      Fixnum.new(parent, position, literal)
+    end
+
+    def self.float(parent, position, literal)
+      Float.new(parent, position, literal)
+    end
+
+    def self.defmacro(name, &block)
+      @macros ||= {}
+      raise "Conflicting macros for #{name}" if @macros[name]
+      @macros[name] = block
+    end
+
+    def self.macro(name)
+      @macros[name]
+    end
+  end
+end
+
+require 'mirah/ast/local'
+require 'mirah/ast/call'
+require 'mirah/ast/flow'
+require 'mirah/ast/literal'
+require 'mirah/ast/method'
+require 'mirah/ast/class'
+require 'mirah/ast/structure'
+require 'mirah/ast/type'
+require 'mirah/ast/intrinsics'