mirah 0.0.12-java → 0.1.0-java

data/lib/mirah/ast/scope.rb

@@ -15,50 +15,19 @@
 
 module Mirah
   module AST
-    module Scoped
-      def scope
-        @scope ||= begin
-          scope = parent
-          until scope.nil? || scope.class.include?(Scope)
-            scope = scope.parent
-          end
-          scope
-        end
-      end
-
-      def containing_scope
-        scope = self.scope.static_scope
-        while !scope.shadowed?(name) && scope.parent && scope.parent.include?(name)
-          scope = scope.parent
-        end
-        scope
-      end
-    end
-
-    module Scope
-      include Scoped
-      attr_writer :static_scope, :type_scope
-      def static_scope
-        @static_scope ||= StaticScope.new(self)
-      end
-    end
-
-    module ClassScoped
-      def class_scope
-        @class_scope ||= begin
-          scope = parent
-          scope = scope.parent until scope.nil? || ClassDefinition === scope
-          scope
-        end
-      end
-    end
-
     class StaticScope
       java_import 'java.util.LinkedHashMap'
+      java_import 'org.mirah.typer.Scope'
+      java_import 'org.mirah.typer.AssignableTypeFuture'
+      java_import 'org.mirah.typer.BaseTypeFuture'
+      java_import 'org.mirah.typer.LocalFuture'
+      java_import 'org.mirah.typer.ErrorType'
+      include Scope
+
       attr_reader :parent
-      attr_writer :self_type, :self_node, :package
+      attr_writer :self_type, :self_node
 
-      def initialize(node, parent=nil)
+      def initialize(node, scoper, parent=nil)
         @scope_node = node
         @vars = {}
         @var_types = {}
@@ -67,8 +36,41 @@ module Mirah
         @imports = {}
         @search_packages = []
         @shadowed = {}
+        @scoper = scoper
+        @temps = Hash.new {|h,k| h[k] = -1}
+        @package_block = nil
+      end
+
+      def context
+        @scope_node
+      end
+
+      def to_s
+        "#<StaticScope node=#{@scope_node.inspect}>"
       end
 
+      def inspect
+        result = "#<StaticScope\n  node=#{@scope_node.inspect}\n  "
+        result << "parent=#{@parent}\n  " if @parent
+        result << "vars=#{locals.inspect}\n  " if @vars.size > 0
+        result << "shadowed=#{@shadowed.keys.inspect}\n  " if @shadowed.size > 0
+        result << "temps=#{@temps.keys.inspect}\n  " if @temps.size > 0
+        result << "package=#{@package}\n  " if @package
+        result << "imports=#{@imports.inspect}\n  " if @imports.size > 0
+        result << "search=#{@search_packages.inspect}\n  " if @search_packages.size > 0
+        result << "self=#{@self_node.inspect}\n  " if @self_node
+        if @self_type
+          result << "self_type=#{@self_type}"
+          if @self_type.isResolved
+            result << " (#{@self_type.resolve.full_name})"
+          end
+          result << "\n  "
+        end
+        result << ">"
+      end
+
+      def toString; inspect; end
+
       def <<(name)
         @vars[name] = true
       end
@@ -85,22 +87,19 @@ module Mirah
         @vars.keys
       end
 
-      def local_type(name)
-        @var_types[name]
+      def temp(name="tmp")
+        "$#{name}$#{@temps[name] += 1}"
       end
 
-      def learn_local_type(name, type)
-        return unless type
-        existing_type = local_type(name)
-        if existing_type
-          unless existing_type.compatible?(type)
-            raise Mirah::Typer::InferenceError.new(
-                "Can't assign #{type.full_name} to " \
-                "variable of type #{existing_type.full_name}")
+      def local_type(name, position=nil)
+        @var_types[name] ||= begin
+          type = LocalFuture.new(name, position)
+          type.onUpdate {|_, resolved| self << name unless resolved.isError}
+          if parent && !shadowed?(name)
+            # TODO what if a var of the same name is later declared in the parent scope?
+            type.parent_set(parent.local_type(name, position))
           end
-          existing_type
-        elsif type
-          @var_types[name] = type
+          type
         end
       end
 
@@ -138,8 +137,9 @@ module Mirah
       end
 
       def outer_scope
-        node = @scope_node.scope
-        node && node.static_scope
+        node = @scope_node
+        return nil if node.nil? || node.parent.nil?
+        @scoper.getScope(node)
       end
 
       def self_type
@@ -156,19 +156,11 @@ module Mirah
         @self_node
       end
 
-      def binding_type(defining_class=nil, mirah=nil)
-        @binding_type ||= begin
-          if parent
-            parent.binding_type(defining_class, mirah)
-          else
-            name = "#{defining_class.name}$#{mirah.tmp}"
-            factory = Mirah::AST.type_factory
-            if factory
-              factory.declare_type(@scope_node, name)
-            else
-              Mirah::AST::TypeReference.new(name, false, false)
-            end
-          end
+      def binding_type
+        if parent
+          parent.binding_type
+        else
+          @binding_type
         end
       end
 
@@ -179,13 +171,26 @@ module Mirah
           @binding_type = type
         end
       end
+      alias :binding_type_set :binding_type=
 
       def has_binding?
         @binding_type != nil || (parent && parent.has_binding?)
       end
 
       def package
-        @package || outer_scope.package
+        @package || (outer_scope && outer_scope.package)
+      end
+
+      def package=(package)
+        raise ArgumentError, "Package already set to #{@package.inspect}" if @package
+        @package = package
+        if @package_block
+          @package_block.call
+        end
+      end
+
+      def on_package_change(&block)
+        @package_block = block
       end
 
       def fetch_imports(map)
@@ -210,14 +215,38 @@ module Mirah
         @cached_packages ||= fetch_packages([])
       end
 
+      def staticImport(type)
+        future = BaseTypeFuture.new(self_type.position)
+        extended = self_type.resolve.include(type.resolve)
+        future.resolved(extended)
+        self.self_type = future
+      end
+
       def import(full_name, short_name)
         return if full_name == short_name
         if short_name == '*'
           @search_packages << full_name.sub(/\.\*$/, '')
+          @cached_packages = nil
         else
           @imports[short_name] = full_name
+          @cached_imports = nil
         end
       end
+      def selfType
+        self_type
+      end  # Should this be resolved?
+      def selfType_set(type)
+        self.self_type = type
+      end
+      def parent_set(scope)
+        self.parent = scope
+      end
+      def package_set(package)
+        self.package = package
+      end
+      def resetDefaultSelfNode
+        self.self_node = :self
+      end
     end
   end
 end

data/lib/mirah/commands.rb

@@ -16,4 +16,4 @@
 require 'mirah/commands/base'
 require 'mirah/commands/run'
 require 'mirah/commands/compile'
-require 'mirah/commands/parse'
+require 'mirah/commands/parse'

data/lib/mirah/commands/base.rb

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mirah/jvm/types'
+#require 'mirah/jvm/types'
 require 'mirah/util/compilation_state'
 require 'mirah/util/argument_processor'
 require 'mirah/errors'
@@ -21,16 +21,17 @@ require 'mirah/errors'
 module Mirah
   module Commands
     class Base
+      include Mirah::Logging::Logged
       def initialize(args)
-        Mirah::AST.type_factory = Mirah::JVM::Types::TypeFactory.new
+        #Mirah::AST.type_factory = Mirah::JVM::Types::TypeFactory.new
         @state = Mirah::Util::CompilationState.new
         @state.command = command_name
         @args = args
         @argument_processor = Mirah::Util::ArgumentProcessor.new(@state, @args)
       end
-      
+
       attr_accessor :state, :args, :argument_processor
-      
+
       def execute_base
         argument_processor.process
         if argument_processor.exit?
@@ -44,11 +45,10 @@ module Mirah
             yield
           rescue Mirah::InternalCompilerError => ice
             Mirah.print_error(ice.message, ice.position) if ice.node
-            raise ice.cause if (ice.cause && state.verbose)
-            raise ice
+            raise ice.cause || ice
           rescue Mirah::MirahError => ex
             Mirah.print_error(ex.message, ex.position)
-            puts ex.backtrace if state.verbose
+            log "{0}\n{1}", [ex.message, ex.backtrace.join("\n")]
             throw :exit, 1
           end
           0

data/lib/mirah/commands/compile.rb

@@ -22,7 +22,7 @@ module Mirah
       def execute
         execute_base do
           generator = Mirah::Generator.new(@state, @state.compiler_class, true, @state.verbose)
-          
+
           generator.generate(@state.args).each do |result|
             filename = "#{@state.destination}#{result.filename}"
             FileUtils.mkdir_p(File.dirname(filename))
@@ -30,10 +30,10 @@ module Mirah
           end
         end
       end
-      
+
       def command_name
         :compile
       end
     end
   end
-end
+end

data/lib/mirah/commands/parse.rb

@@ -20,15 +20,17 @@ module Mirah
     class Parse < Base
       def execute
         execute_base do
-          parser = Mirah::Parser.new(@state, false)
-          
-          parser.parse_from_args(args)
+          parser = Mirah::Parser.new(@state, nil, false)
+
+          parser.parse_from_args(args).each do |ast|
+            puts parser.format_ast(ast)
+          end
         end
       end
-      
+
       def command_name
         :parse
       end
     end
   end
-end
+end

data/lib/mirah/commands/run.rb

@@ -22,35 +22,29 @@ module Mirah
       def execute
         execute_base do
           main = nil
+          class_map = {}
 
-          
           # generate all bytes for all classes
-          class_map = generate_class_map 
-          
+          generator = Mirah::Generator.new(@state, @state.compiler_class, false, @state.verbose)
+
+          generator.generate(args).each do |result|
+            class_map[result.classname.gsub(/\//, '.')] = Mirah::Util::ClassLoader.binary_string result.bytes
+          end
+
           # load all classes
           main = load_classes_and_find_main(class_map)
-          
+
           # run the main method we found
           run_main(main)
         end
       end
-      
+
       def command_name
         :run
       end
-      
-      private
 
-      def generate_class_map
-        generator = Mirah::Generator.new(@state, @state.compiler_class, false, @state.verbose)
+      private
 
-        class_map = {}
-        generator.generate(args).each do |result|
-          class_map[result.classname.gsub(/\//, '.')] = Mirah::Util::ClassLoader.binary_string result.bytes
-        end
-        class_map
-      end
-      
       def load_classes_and_find_main(class_map)
         main = nil
         dcl = Mirah::Util::ClassLoader.new(JRuby.runtime.jruby_class_loader, class_map)
@@ -61,7 +55,7 @@ module Mirah
         end
         main
       end
-      
+
       def run_main(main)
         if main
           begin
@@ -71,8 +65,7 @@ module Mirah
             raise e
           end
         else
-          $stderr.puts "No main found"
-          exit 1
+          puts "No main found" unless @state.version_printed || @state.help_printed
         end
       end
     end

data/lib/mirah/compiler.rb

@@ -13,50 +13,42 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mirah/compiler/call'
-require 'mirah/compiler/class'
-require 'mirah/compiler/flow'
-require 'mirah/compiler/literal'
-require 'mirah/compiler/local'
-require 'mirah/compiler/method'
-require 'mirah/compiler/structure'
-require 'mirah/compiler/type'
-
 module Mirah
   module Compiler
     class ASTCompiler
-      def initialize(compiler_class, logging)
+      def initialize(config, compiler_class, logging)
+        @config = config
         @compiler_class = compiler_class
         @logging = logging
       end
-      
-      attr_accessor :compiler_class, :logging
-      
-      def compile_asts(nodes)
+
+      attr_accessor :compiler_class, :compiler, :logging
+
+      def compile_asts(nodes, scoper, typer)
         results = []
         puts "Compiling..." if logging
         nodes.each do |ast|
-          puts "  #{ast.position.file}" if logging
-          compile_ast(ast) do |filename, builder|
+          puts "  #{ast.position.source.name}" if logging
+          compile_ast(ast, scoper, typer) do |filename, builder|
             results << CompilerResult.new(filename, builder.class_name, builder.generate)
           end
         end
         results
       end
-      
-      def compile_ast(ast, &block)
-        compiler = compiler_class.new
-        ast.compile(compiler, false)
+
+      def compile_ast(ast, scoper, typer, &block)
+        @compiler = compiler_class.new(@config, scoper, typer)
+        compiler.visit(ast, nil)
         compiler.generate(&block)
       end
     end
-    
+
     class CompilerResult
       def initialize(filename, classname, bytes)
         @filename, @classname, @bytes = filename, classname, bytes
       end
-      
+
       attr_accessor :filename, :classname, :bytes
     end
   end
-end
+end