Refactor: everything is an object

META6.json

@@ -15,11 +15,11 @@
         "_007::Parser::Actions" : "lib/_007/Parser/Actions.pm",
         "_007::Parser::Syntax" : "lib/_007/Parser/Syntax.pm",
         "_007::Precedence" : "lib/_007/Precedence.pm",
-        "_007::Q" : "lib/_007/Q.pm",
         "_007::Runtime" : "lib/_007/Runtime.pm",
         "_007::Builtins" : "lib/_007/Builtins.pm",
         "_007::Test" : "lib/_007/Test.pm",
-        "_007::Val" : "lib/_007/Val.pm"
+        "_007::Object" : "lib/_007/Object.pm",
+        "_007::Type" : "lib/_007/Type.pm"
     },
     "support" : { "source"    : "git://github.com/masak/007.git" }
 }

bin/count-builtins

@@ -0,0 +1,74 @@
+#!/usr/bin/env perl6
+use v6;
+
+my $type_count = 0;
+my $bound_method_count = 0;
+my $runtime_builtin_method_count = 0;
+my $built_in_subs = 0;
+my $exception_types_in_007 = 0;
+my $exception_types_in_perl6 = 0;
+
+for <lib/_007/Type.pm> -> $file {
+    for $file.IO.lines {
+        if /^ "TYPE<" (<-[>]>+) ">" \h* "=" \h* "_007::Type.new(" / {
+            $type_count++;
+            if $0 eq "Exception" || $0.starts-with("X::") {
+                $exception_types_in_007++;
+            }
+        }
+    }
+}
+
+for <lib/_007/Object.pm> -> $file {
+    for $file.IO.lines {
+        if /^ "sub bound-method(" / ff /^ "}" / {
+            if /^ " " ** 4 \S / {
+                if /^ \h* "if \$object.isa" / {
+                    $bound_method_count++;
+                }
+                elsif /^ \h* "}" / {
+                    # do nothing
+                }
+                elsif /^ \h* "die " / {
+                    # do nothing
+                }
+                else {
+                    die "Unexpected line: `$_`";
+                }
+            }
+        }
+    }
+}
+
+for <lib/_007/Runtime.pm> -> $file {
+    for $file.IO.lines {
+        if /^ \h* "return builtin(" / {
+            $runtime_builtin_method_count++;
+        }
+    }
+}
+
+for <lib/_007/Builtins.pm> -> $file {
+    for $file.IO.lines {
+        if /^ \h* "my @builtins ="/ ff /^ \h* ";" \h* $/ {
+            if /^ \h* \S+ \h* "=>" \h* ["->" | "sub" | "macro-op" | "op"] / {
+                $built_in_subs++;
+            }
+        }
+    }
+}
+
+for <lib/_007/Object.pm lib/_007/OpScope.pm lib/_007/Parser/Actions.pm lib/_007/Runtime.pm> -> $file {
+    for $file.IO.lines {
+        if /^ "class X::" / {
+            $exception_types_in_perl6++;
+        }
+    }
+}
+
+say "Types: $type_count";
+say "Bound methods: $bound_method_count";
+say "Built-in methods in Runtime.pm: $runtime_builtin_method_count";
+say "Built-in subs: $built_in_subs";
+say "Exception types in 007: $exception_types_in_007";
+say "Exception types in Perl 6: $exception_types_in_perl6";

examples/hanoi.007

@@ -8,7 +8,7 @@ constant DISK = {
 };
 
 my state = [
-    [DISK.huge, DISK.large, DISK.small, DISK.tiny],
+    [DISK["huge"], DISK["large"], DISK["small"], DISK["tiny"]],
     [],
     []
 ];

lib/_007/Backend/JavaScript.pm

@@ -1,5 +1,4 @@
-use _007::Val;
-use _007::Q;
+use _007::Object;
 
 my %builtins =
     "say" => q:to '----',
@@ -10,14 +9,14 @@ my %builtins =
 ;
 
 class _007::Backend::JavaScript {
-    method emit(Q::CompUnit $compunit) {
+    method emit(_007::Object $compunit) {
         return ""
-            unless $compunit.block.statementlist.statements.elements;
+            unless $compunit.properties<block>.properties<statementlist>.properties<statements>.value;
 
         my @builtins;
         my @main;
 
-        for $compunit.block.statementlist.statements.elements -> $stmt {
+        for $compunit.properties<block>.properties<statementlist>.properties<statements>.value -> $stmt {
             emit-stmt($stmt);
         }
 
@@ -29,38 +28,40 @@ class _007::Backend::JavaScript {
             \})();
             PROGRAM
 
-        multi emit-stmt(Q::Statement $stmt) {
-            die "Cannot handle {$stmt.^name}";
-        }
+        sub emit-stmt(_007::Object $stmt) {
+            if $stmt.isa("Q::Statement::Expr") {
+                my $expr = $stmt.properties<expr>;
+                when $expr.isa("Q::Postfix::Call")
+                    && $expr.properties<operand>.isa("Q::Identifier")
+                    && $expr.properties<operand>.properties<name>.value eq "say" {
 
-        multi emit-stmt(Q::Statement::Expr $stmt) {
-            my $expr = $stmt.expr;
-            when $expr ~~ Q::Postfix::Call
-                && $expr.operand ~~ Q::Identifier
-                && $expr.operand.name.value eq "say" {
+                    @builtins.push(%builtins<say>);
+                    my @arguments = $expr.properties<argumentlist>.properties<arguments>.value.map: {
+                        die "Cannot handle non-literal-Str arguments just yet!"
+                            unless .isa("Q::Literal::Str");
+                        # XXX: should really type-check the result of the .repr() call
+                        bound-method(.properties<value>, "repr")().value;
+                    };
+                    @main.push("say({@arguments.join(", ")});");
+                }
 
-                @builtins.push(%builtins<say>);
-                my @arguments = $expr.argumentlist.arguments.elements.map: {
-                    die "Cannot handle non-literal-Str arguments just yet!"
-                        unless $_ ~~ Q::Literal::Str;
-                    .value.quoted-Str;
-                };
-                @main.push("say({@arguments.join(", ")});");
+                die "Cannot handle this type of Q::Statement::Expr yet!";
             }
-
-            die "Cannot handle this type of Q::Statement::Expr yet!";
-        }
-
-        multi emit-stmt(Q::Statement::My $stmt) {
-            my $name = $stmt.identifier.name.value;
-            if $stmt.expr !~~ NONE {
-                die "Cannot handle non-literal-Int rhs just yet!"
-                        unless $stmt.expr ~~ Q::Literal::Int;
-                my $expr = $stmt.expr.value.Str;
-                @main.push("let {$name} = {$expr};");
+            elsif $stmt.isa("Q::Statement::My") {
+                my $name = $stmt.properties<identifier>.properties<name>.value;
+                if $stmt.properties<expr> !=== NONE {
+                    die "Cannot handle non-literal-Int rhs just yet!"
+                        unless $stmt.properties<expr>.isa("Q::Literal::Int");
+                    # XXX: should really type-check the result of the .Str() call
+                    my $expr = bound-method($stmt.properties<expr>.properties<value>, "Str")().value;
+                    @main.push("let {$name} = {$expr};");
+                }
+                else {
+                    @main.push("let {$name};");
+                }
             }
             else {
-                @main.push("let {$name};");
+                die "Cannot handle {$stmt.type.name}";
             }
         }
     }