delorean_lang 0.5.1 → 0.5.2

data/Gemfile

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in delorean.gemspec
 gemspec
 
 group :development, :test do
-  gem 'rspec-instafail', require: false
   gem 'pry'
+  gem 'rspec-instafail', require: false
 end

data/README.md

@@ -121,6 +121,28 @@ newly defined `teen_min`.  Therefore, `IndiaInfo.is_teenager` with
 input of `age = 10` will evaluate to `true`.  Whereas,
 `USInfo.is_teenager` with input of `age = 10` will evaluate to `false`.
 
+### Debugging
+
+You can use `(ERR())` to add a breakpoint:
+
+```
+    USInfo:
+		age = ?
+		teen_max = 19
+		teen_min = 13
+		is_teenager = (ERR()) && age >= teen_min && age <= teen_max
+
+```
+
+Then you can call attributes by using their mangled name (e.g. attr__D) and passing the context. attr__D(_e). Of course, you can use `ls` to list available methods.
+
+```
+  teen_max__D(_e) # 19
+  age__D(_e)
+```
+
+### TODO
+
 TODO: provide details on the following topics:
 
 * Supported data types

data/Rakefile

@@ -1,2 +1,4 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'

data/delorean.gemspec

@@ -1,25 +1,26 @@
-require File.expand_path('../lib/delorean/version', __FILE__)
+# frozen_string_literal: true
+
+require File.expand_path('lib/delorean/version', __dir__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Arman Bostani"]
-  gem.email         = ["arman.bostani@pnmac.com"]
-  gem.description   = %q{A "compiler" for the Delorean programming language}
-  gem.summary       = %q{Delorean compiler}
-  gem.homepage      = "https://github.com/arman000/delorean_lang"
+  gem.authors       = ['Arman Bostani']
+  gem.email         = ['arman.bostani@pnmac.com']
+  gem.description   = 'A "compiler" for the Delorean programming language'
+  gem.summary       = 'Delorean compiler'
+  gem.homepage      = 'https://github.com/arman000/delorean_lang'
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "delorean_lang"
-  gem.require_paths = ["lib"]
+  gem.name          = 'delorean_lang'
+  gem.require_paths = ['lib']
   gem.version       = Delorean::VERSION
   gem.licenses      = ['MIT']
 
-
-  gem.add_dependency "treetop", "~> 1.5"
-  gem.add_dependency "activerecord", ">= 3.2"
-  gem.add_development_dependency "rspec", '~> 2.1'
-  gem.add_development_dependency "sqlite3", '~> 1.3.10'
-  gem.add_development_dependency "pry"
-  gem.add_development_dependency "rubocop"
+  gem.add_dependency 'activerecord', '>= 3.2'
+  gem.add_dependency 'treetop', '~> 1.5'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'rspec', '~> 2.1'
+  gem.add_development_dependency 'rubocop'
+  gem.add_development_dependency 'sqlite3', '~> 1.3.10'
 end

data/lib/delorean/abstract_container.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'delorean/base'
 
 module Delorean
   class AbstractContainer
-    def get_engine(name)
-      raise "get_engine needs to be overriden"
+    def get_engine(_name)
+      raise 'get_engine needs to be overriden'
     end
   end
 end

data/lib/delorean/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/time'
 require 'active_record'
 require 'bigdecimal'
@@ -6,7 +8,6 @@ require 'delorean/ruby/whitelists/default'
 require 'delorean/cache'
 
 module Delorean
-
   ::Delorean::Ruby.whitelist = ::Delorean::Ruby::Whitelists::Default.new
 
   ::Delorean::Cache.adapter = ::Delorean::Cache::Adapters::RubyCache.new(
@@ -22,7 +23,7 @@ module Delorean
         # This is pretty awful.  NOTE: can't sanitize params as Marty
         # patches NodeCall and modifies params to send _parent_id.
         # This whole thing needs to be redone.
-        @cp ||= Hash[params]
+        @cloned_params ||= Hash[params]
       end
 
       def evaluate(attr)
@@ -30,30 +31,28 @@ module Delorean
       end
 
       def /(args)
-        begin
-          case args
-          when Array
-            engine.eval_to_hash(node, args, cloned_params)
-          when String
-            self.evaluate(args)
-          else
-            raise "non-array/string arg to /"
-          end
-        rescue => exc
-          Delorean::Engine.grok_runtime_exception(exc)
+        case args
+        when Array
+          engine.eval_to_hash(node, args, cloned_params)
+        when String
+          evaluate(args)
+        else
+          raise 'non-array/string arg to /'
         end
+      rescue StandardError => exc
+        Delorean::Engine.grok_runtime_exception(exc)
       end
 
       # FIXME: % should also support string as args
       def %(args)
-        raise "non-array arg to %" unless args.is_a?(Array)
+        raise 'non-array arg to %' unless args.is_a?(Array)
 
         engine.eval_to_hash(node, args, cloned_params)
       end
 
       # add new arguments, results in a new NodeCall
       def +(args)
-        raise "bad arg to %" unless args.is_a?(Hash)
+        raise 'bad arg to %' unless args.is_a?(Hash)
 
         NodeCall.new(_e, engine, node, params.merge(args))
       end
@@ -72,6 +71,7 @@ module Delorean
           # {}.length.  i.e. length is a whitelisted function, but not
           # an attr. This implementation returns nil instead of 0.
           return obj[attr] if obj.member?(attr)
+
           return attr.is_a?(String) ? obj[attr.to_sym] : nil
         end
 
@@ -91,9 +91,11 @@ module Delorean
 
         begin
           return _instance_call(obj, attr, [], _e)
-        rescue => exc
-          raise InvalidGetAttribute,
-          "attr lookup failed: '#{attr}' on <#{obj.class}> #{obj} - #{exc}"
+        rescue StandardError => exc
+          raise(
+            InvalidGetAttribute,
+            "attr lookup failed: '#{attr}' on <#{obj.class}> #{obj} - #{exc}"
+          )
         end
       end
 
@@ -105,14 +107,16 @@ module Delorean
         when nil
           # FIXME: even Javascript which is superpermissive raises an
           # exception on null getattr.
-          return nil
+          nil
         when Hash, NodeCall, Class, OpenStruct
           raise InvalidIndex unless args.length == 1
+
           _get_attr(obj, args[0], _e)
         when Array, String, MatchData
           raise InvalidIndex unless args.length <= 2 &&
                                     args[0].is_a?(Integer) &&
                                     (args[1].nil? || args[1].is_a?(Integer))
+
           obj[*args]
         else
           raise InvalidIndex
@@ -122,8 +126,7 @@ module Delorean
       ######################################################################
 
       def self._sanitize_hash(_e)
-        _e.each_with_object({}) do
-          |(k,v), h|
+        _e.each_with_object({}) do |(k, v), h|
           h[k] = v if k.is_a?(Integer) || k =~ /\A[a-z][A-Za-z0-9_]*\z/
         end
       end
@@ -131,7 +134,7 @@ module Delorean
       ######################################################################
 
       def self._err(*args)
-        str = args.map(&:to_s).join(", ")
+        str = args.map(&:to_s).join(', ')
         raise str
       end
 
@@ -164,15 +167,15 @@ module Delorean
           return obj.send(msg, *args)
         end
 
-        cls = obj.class
-
         matcher = ::Delorean::Ruby.whitelist.matcher(method_name: msg)
 
         raise "no such method #{method}" unless matcher
 
-        return(
-          _instance_call(obj, matcher.match_to, args, _e)
-        ) if matcher.match_to?
+        if matcher.match_to?
+          return(
+            _instance_call(obj, matcher.match_to, args, _e)
+          )
+        end
 
         matcher.match!(klass: obj.class, args: args)
 

data/lib/delorean/cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'delorean/cache/adapters'
 
 module Delorean

data/lib/delorean/cache/adapters.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'delorean/cache/adapters/ruby_cache'
 
 module Delorean

data/lib/delorean/cache/adapters/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delorean
   module Cache
     module Adapters

data/lib/delorean/cache/adapters/ruby_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative './base'
 
 module Delorean
@@ -20,14 +22,17 @@ module Delorean
         def fetch_item(klass:, cache_key:, default: nil)
           subh = lookup_cache.fetch(klass, default)
           return default if subh == default
+
           v = subh.fetch(cache_key, default)
           return default if v == default
+
           v
         end
 
         def cache_key(klass:, method_name:, args:)
           [method_name] + args.map do |arg|
             next arg.id if arg.respond_to?(:id)
+
             arg
           end.freeze
         end

data/lib/delorean/const.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Delorean
-  SIG = "_SIG"
-  MOD = "DELOREAN__"
-  POST = "__D"
+  SIG = '_SIG'.freeze
+  MOD = 'DELOREAN__'.freeze
+  POST = '__D'.freeze
 end

data/lib/delorean/debug.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delorean
   class Debug
     @debug_set = Set[]
@@ -8,15 +10,14 @@ module Delorean
     end
 
     def self.log(obj)
-      File.open(@log_file, 'a+') {
-        |f|
+      File.open(@log_file, 'a+') do |f|
         f.write obj.inspect
         f.write "\n"
-      }
+      end
     end
 
-    def self.debug_set
-      @debug_set
+    class << self
+      attr_reader :debug_set
     end
   end
 end

data/lib/delorean/delorean.rb

@@ -140,7 +140,6 @@ module Delorean
     def m
       elements[0]
     end
-
   end
 
   module Formula4
@@ -151,20 +150,37 @@ module Delorean
     def mod
       elements[3]
     end
+  end
+
+  module Formula5
+    def m
+      elements[0]
+    end
+
+  end
+
+  module Formula6
+    def n
+      elements[0]
+    end
+
+    def mod
+      elements[3]
+    end
 
     def p
       elements[4]
     end
   end
 
-  module Formula5
+  module Formula7
     def n
       elements[0]
     end
 
   end
 
-  module Formula6
+  module Formula8
     def sp
       elements[1]
     end
@@ -344,41 +360,22 @@ module Delorean
               end
               s25 << r28
               if r28
-                i31, s31 = index, []
-                r32 = _nt_class_name
-                s31 << r32
-                if r32
-                  if (match_len = has_terminal?('::', false, index))
-                    r33 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                    @index += match_len
-                  else
-                    terminal_parse_failure('\'::\'')
-                    r33 = nil
-                  end
-                  s31 << r33
-                end
-                if s31.last
-                  r31 = instantiate_node(SyntaxNode,input, i31...index, s31)
-                  r31.extend(Formula3)
+                i30, s30 = index, []
+                r31 = _nt_class_name_import_nested
+                s30 << r31
+                if s30.last
+                  r30 = instantiate_node(SyntaxNode,input, i30...index, s30)
+                  r30.extend(Formula3)
                 else
-                  @index = i31
-                  r31 = nil
-                end
-                if r31
-                  r30 = r31
-                else
-                  r30 = instantiate_node(SyntaxNode,input, index...index)
+                  @index = i30
+                  r30 = nil
                 end
                 s25 << r30
-                if r30
-                  r34 = _nt_class_name
-                  s25 << r34
-                end
               end
             end
           end
           if s25.last
-            r25 = instantiate_node(SubNode,input, i25...index, s25)
+            r25 = instantiate_node(SubNodeNested,input, i25...index, s25)
             r25.extend(Formula4)
           else
             @index = i25
@@ -388,60 +385,126 @@ module Delorean
             r25 = SyntaxNode.new(input, (index-1)...index) if r25 == true
             r0 = r25
           else
-            i35, s35 = index, []
-            r36 = _nt_class_name
-            s35 << r36
-            if r36
+            i32, s32 = index, []
+            r33 = _nt_class_name
+            s32 << r33
+            if r33
               if (match_len = has_terminal?(':', false, index))
-                r37 = true
+                r34 = true
                 @index += match_len
               else
                 terminal_parse_failure('\':\'')
-                r37 = nil
+                r34 = nil
+              end
+              s32 << r34
+              if r34
+                r36 = _nt_sp
+                if r36
+                  r35 = r36
+                else
+                  r35 = instantiate_node(SyntaxNode,input, index...index)
+                end
+                s32 << r35
+                if r35
+                  i38, s38 = index, []
+                  r39 = _nt_class_name
+                  s38 << r39
+                  if r39
+                    if (match_len = has_terminal?('::', false, index))
+                      r40 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                      @index += match_len
+                    else
+                      terminal_parse_failure('\'::\'')
+                      r40 = nil
+                    end
+                    s38 << r40
+                  end
+                  if s38.last
+                    r38 = instantiate_node(SyntaxNode,input, i38...index, s38)
+                    r38.extend(Formula5)
+                  else
+                    @index = i38
+                    r38 = nil
+                  end
+                  if r38
+                    r37 = r38
+                  else
+                    r37 = instantiate_node(SyntaxNode,input, index...index)
+                  end
+                  s32 << r37
+                  if r37
+                    r41 = _nt_class_name
+                    s32 << r41
+                  end
+                end
               end
-              s35 << r37
             end
-            if s35.last
-              r35 = instantiate_node(BaseNode,input, i35...index, s35)
-              r35.extend(Formula5)
+            if s32.last
+              r32 = instantiate_node(SubNode,input, i32...index, s32)
+              r32.extend(Formula6)
             else
-              @index = i35
-              r35 = nil
+              @index = i32
+              r32 = nil
             end
-            if r35
-              r35 = SyntaxNode.new(input, (index-1)...index) if r35 == true
-              r0 = r35
+            if r32
+              r32 = SyntaxNode.new(input, (index-1)...index) if r32 == true
+              r0 = r32
             else
-              i38, s38 = index, []
-              if (match_len = has_terminal?('import', false, index))
-                r39 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                @index += match_len
-              else
-                terminal_parse_failure('\'import\'')
-                r39 = nil
-              end
-              s38 << r39
-              if r39
-                r40 = _nt_sp
-                s38 << r40
-                if r40
-                  r41 = _nt_class_name
-                  s38 << r41
+              i42, s42 = index, []
+              r43 = _nt_class_name
+              s42 << r43
+              if r43
+                if (match_len = has_terminal?(':', false, index))
+                  r44 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('\':\'')
+                  r44 = nil
                 end
+                s42 << r44
               end
-              if s38.last
-                r38 = instantiate_node(Import,input, i38...index, s38)
-                r38.extend(Formula6)
+              if s42.last
+                r42 = instantiate_node(BaseNode,input, i42...index, s42)
+                r42.extend(Formula7)
               else
-                @index = i38
-                r38 = nil
+                @index = i42
+                r42 = nil
               end
-              if r38
-                r38 = SyntaxNode.new(input, (index-1)...index) if r38 == true
-                r0 = r38
+              if r42
+                r42 = SyntaxNode.new(input, (index-1)...index) if r42 == true
+                r0 = r42
               else
-                @index = i0
-                r0 = nil
+                i45, s45 = index, []
+                if (match_len = has_terminal?('import', false, index))
+                  r46 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                  @index += match_len
+                else
+                  terminal_parse_failure('\'import\'')
+                  r46 = nil
+                end
+                s45 << r46
+                if r46
+                  r47 = _nt_sp
+                  s45 << r47
+                  if r47
+                    r48 = _nt_class_name_import
+                    s45 << r48
+                  end
+                end
+                if s45.last
+                  r45 = instantiate_node(Import,input, i45...index, s45)
+                  r45.extend(Formula8)
+                else
+                  @index = i45
+                  r45 = nil
+                end
+                if r45
+                  r45 = SyntaxNode.new(input, (index-1)...index) if r45 == true
+                  r0 = r45
+                else
+                  @index = i0
+                  r0 = nil
+                end
               end
             end
           end
@@ -509,6 +572,241 @@ module Delorean
     r0
   end
 
+  module ClassNameImport0
+  end
+
+  module ClassNameImport1
+  end
+
+  def _nt_class_name_import
+    start_index = index
+    if node_cache[:class_name_import].has_key?(index)
+      cached = node_cache[:class_name_import][index]
+      if cached
+        node_cache[:class_name_import][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
+      r1 = true
+      @index += 1
+    else
+      terminal_parse_failure('[A-Z]')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9_]'] ||= Regexp.new(gr), :regexp, index)
+          r3 = true
+          @index += 1
+        else
+          terminal_parse_failure('[a-zA-Z0-9_]')
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        s4, i4 = [], index
+        loop do
+          i5, s5 = index, []
+          if (match_len = has_terminal?('::', false, index))
+            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('\'::\'')
+            r6 = nil
+          end
+          s5 << r6
+          if r6
+            if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
+              r7 = true
+              @index += 1
+            else
+              terminal_parse_failure('[A-Z]')
+              r7 = nil
+            end
+            s5 << r7
+            if r7
+              s8, i8 = [], index
+              loop do
+                if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9_]'] ||= Regexp.new(gr), :regexp, index)
+                  r9 = true
+                  @index += 1
+                else
+                  terminal_parse_failure('[a-zA-Z0-9_]')
+                  r9 = nil
+                end
+                if r9
+                  s8 << r9
+                else
+                  break
+                end
+              end
+              r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+              s5 << r8
+            end
+          end
+          if s5.last
+            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+            r5.extend(ClassNameImport0)
+          else
+            @index = i5
+            r5 = nil
+          end
+          if r5
+            s4 << r5
+          else
+            break
+          end
+        end
+        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(ClassNameImport1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:class_name_import][start_index] = r0
+
+    r0
+  end
+
+  module ClassNameImportNested0
+  end
+
+  module ClassNameImportNested1
+  end
+
+  def _nt_class_name_import_nested
+    start_index = index
+    if node_cache[:class_name_import_nested].has_key?(index)
+      cached = node_cache[:class_name_import_nested][index]
+      if cached
+        node_cache[:class_name_import_nested][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
+      r1 = true
+      @index += 1
+    else
+      terminal_parse_failure('[A-Z]')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9_]'] ||= Regexp.new(gr), :regexp, index)
+          r3 = true
+          @index += 1
+        else
+          terminal_parse_failure('[a-zA-Z0-9_]')
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        s4, i4 = [], index
+        loop do
+          i5, s5 = index, []
+          if (match_len = has_terminal?('::', false, index))
+            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('\'::\'')
+            r6 = nil
+          end
+          s5 << r6
+          if r6
+            if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
+              r7 = true
+              @index += 1
+            else
+              terminal_parse_failure('[A-Z]')
+              r7 = nil
+            end
+            s5 << r7
+            if r7
+              s8, i8 = [], index
+              loop do
+                if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9_]'] ||= Regexp.new(gr), :regexp, index)
+                  r9 = true
+                  @index += 1
+                else
+                  terminal_parse_failure('[a-zA-Z0-9_]')
+                  r9 = nil
+                end
+                if r9
+                  s8 << r9
+                else
+                  break
+                end
+              end
+              r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+              s5 << r8
+            end
+          end
+          if s5.last
+            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+            r5.extend(ClassNameImportNested0)
+          else
+            @index = i5
+            r5 = nil
+          end
+          if r5
+            s4 << r5
+          else
+            break
+          end
+        end
+        if s4.size < 2
+          @index = i4
+          r4 = nil
+        else
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(ClassNameImportNested1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:class_name_import_nested][start_index] = r0
+
+    r0
+  end
+
   module Expression0
     def args
       elements[2]
@@ -2455,13 +2753,19 @@ module Delorean
   end
 
   module Value0
+    def c
+      elements[0]
+    end
+  end
+
+  module Value1
     def m
       elements[0]
     end
 
   end
 
-  module Value1
+  module Value2
     def mod
       elements[0]
     end
@@ -2471,7 +2775,7 @@ module Delorean
     end
   end
 
-  module Value2
+  module Value3
     def e
       elements[2]
     end
@@ -2546,39 +2850,11 @@ module Delorean
                           r0 = r11
                         else
                           i12, s12 = index, []
-                          i14, s14 = index, []
-                          r15 = _nt_class_name
-                          s14 << r15
-                          if r15
-                            if (match_len = has_terminal?('::', false, index))
-                              r16 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                              @index += match_len
-                            else
-                              terminal_parse_failure('\'::\'')
-                              r16 = nil
-                            end
-                            s14 << r16
-                          end
-                          if s14.last
-                            r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
-                            r14.extend(Value0)
-                          else
-                            @index = i14
-                            r14 = nil
-                          end
-                          if r14
-                            r13 = r14
-                          else
-                            r13 = instantiate_node(SyntaxNode,input, index...index)
-                          end
+                          r13 = _nt_class_name_import
                           s12 << r13
-                          if r13
-                            r17 = _nt_class_name
-                            s12 << r17
-                          end
                           if s12.last
-                            r12 = instantiate_node(NodeAsValue,input, i12...index, s12)
-                            r12.extend(Value1)
+                            r12 = instantiate_node(NodeAsValueNested,input, i12...index, s12)
+                            r12.extend(Value0)
                           else
                             @index = i12
                             r12 = nil
@@ -2587,60 +2863,103 @@ module Delorean
                             r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
                             r0 = r12
                           else
-                            i18, s18 = index, []
-                            if (match_len = has_terminal?('(', false, index))
-                              r19 = true
-                              @index += match_len
+                            i14, s14 = index, []
+                            i16, s16 = index, []
+                            r17 = _nt_class_name
+                            s16 << r17
+                            if r17
+                              if (match_len = has_terminal?('::', false, index))
+                                r18 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                                @index += match_len
+                              else
+                                terminal_parse_failure('\'::\'')
+                                r18 = nil
+                              end
+                              s16 << r18
+                            end
+                            if s16.last
+                              r16 = instantiate_node(SyntaxNode,input, i16...index, s16)
+                              r16.extend(Value1)
                             else
-                              terminal_parse_failure('\'(\'')
-                              r19 = nil
+                              @index = i16
+                              r16 = nil
                             end
-                            s18 << r19
-                            if r19
-                              r21 = _nt_sp
-                              if r21
-                                r20 = r21
+                            if r16
+                              r15 = r16
+                            else
+                              r15 = instantiate_node(SyntaxNode,input, index...index)
+                            end
+                            s14 << r15
+                            if r15
+                              r19 = _nt_class_name
+                              s14 << r19
+                            end
+                            if s14.last
+                              r14 = instantiate_node(NodeAsValue,input, i14...index, s14)
+                              r14.extend(Value2)
+                            else
+                              @index = i14
+                              r14 = nil
+                            end
+                            if r14
+                              r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
+                              r0 = r14
+                            else
+                              i20, s20 = index, []
+                              if (match_len = has_terminal?('(', false, index))
+                                r21 = true
+                                @index += match_len
                               else
-                                r20 = instantiate_node(SyntaxNode,input, index...index)
+                                terminal_parse_failure('\'(\'')
+                                r21 = nil
                               end
-                              s18 << r20
-                              if r20
-                                r22 = _nt_expression
-                                s18 << r22
+                              s20 << r21
+                              if r21
+                                r23 = _nt_sp
+                                if r23
+                                  r22 = r23
+                                else
+                                  r22 = instantiate_node(SyntaxNode,input, index...index)
+                                end
+                                s20 << r22
                                 if r22
-                                  r24 = _nt_sp
+                                  r24 = _nt_expression
+                                  s20 << r24
                                   if r24
-                                    r23 = r24
-                                  else
-                                    r23 = instantiate_node(SyntaxNode,input, index...index)
-                                  end
-                                  s18 << r23
-                                  if r23
-                                    if (match_len = has_terminal?(')', false, index))
-                                      r25 = true
-                                      @index += match_len
+                                    r26 = _nt_sp
+                                    if r26
+                                      r25 = r26
                                     else
-                                      terminal_parse_failure('\')\'')
-                                      r25 = nil
+                                      r25 = instantiate_node(SyntaxNode,input, index...index)
+                                    end
+                                    s20 << r25
+                                    if r25
+                                      if (match_len = has_terminal?(')', false, index))
+                                        r27 = true
+                                        @index += match_len
+                                      else
+                                        terminal_parse_failure('\')\'')
+                                        r27 = nil
+                                      end
+                                      s20 << r27
                                     end
-                                    s18 << r25
                                   end
                                 end
                               end
-                            end
-                            if s18.last
-                              r18 = instantiate_node(Expr,input, i18...index, s18)
-                              r18.extend(Value2)
-                            else
-                              @index = i18
-                              r18 = nil
-                            end
-                            if r18
-                              r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
-                              r0 = r18
-                            else
-                              @index = i0
-                              r0 = nil
+                              if s20.last
+                                r20 = instantiate_node(Expr,input, i20...index, s20)
+                                r20.extend(Value3)
+                              else
+                                @index = i20
+                                r20 = nil
+                              end
+                              if r20
+                                r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
+                                r0 = r20
+                              else
+                                @index = i0
+                                r0 = nil
+                              end
                             end
                           end
                         end