[truffle] Implement native types on variables

Author: pmurias

src/vm/jvm/Truffle.nqp

@@ -417,6 +417,14 @@ class QAST::TruffleCompiler {
         has $!qast; # The QAST::Block
         has $!outer; # Outer block's BlockInfo
         has @!params; # the parameters the block takes
+        has $!var_types; # Mapping of variables types
+
+        method var_type($var) {
+            $!var_types{$var.scope}{$var.name};
+        }
+        method register_var_type($var, $type) {
+            $!var_types{$var.scope}{$var.name} := $type;
+        }
 
         method new($qast, $outer) {
             my $obj := nqp::create(self);
@@ -428,13 +436,15 @@ class QAST::TruffleCompiler {
             $!qast := $qast;
             $!outer := $outer;
             @!params := nqp::list();
+            $!var_types := nqp::hash('local', nqp::hash(), 'lexical', nqp::hash());
         }
 
         method add_param($param) {
             @!params.push($param);
         }
 
         method params() { @!params }
+        method outer() { $!outer }
     }
 
     method compile(QAST::CompUnit $cu) {
@@ -547,6 +557,37 @@ class QAST::TruffleCompiler {
         }
     }
 
+    my @types := [$OBJ, $INT, $NUM, $STR];
+    method type_from_typeobj($typeobj) {
+        my int $type := nqp::objprimspec($typeobj);
+        @types[$type];
+    }
+
+    method figure_out_type(QAST::Var $var) {
+        my $type := $*BLOCK.var_type($var);
+        if nqp::defined($type) {
+            return $type;
+        }
+
+        if $var.scope eq 'lexical' || $var.scope eq 'typevar' {
+            # Try to find it in an outer scope.
+            my $cur_block := $*BLOCK.outer();
+            while nqp::istype($cur_block, BlockInfo) {
+                $type := $cur_block.var_type($var);
+                if nqp::defined($type) {
+                    return $type;
+                }
+                else {
+                    $cur_block := $cur_block.outer();
+                }
+            }
+        }
+
+        # TODO var not found and has .returns
+
+        $OBJ;
+    }
+
     proto method as_truffle($node, :$want) {
         if nqp::defined($want) {
             if nqp::istype($node, QAST::Want) {
@@ -567,6 +608,8 @@ class QAST::TruffleCompiler {
             $*HLL := $node.hll;
         }
 
+        my $*BLOCK := BlockInfo.new(NQPMu, NQPMu);
+
         TAST.new($OBJ, ['stmts', self.as_truffle($node[0][1], :want($VOID)).tree, self.as_truffle($node[0][3], :want($OBJ)).tree]);
     }
 
@@ -688,21 +731,25 @@ class QAST::TruffleCompiler {
     multi method as_truffle(QAST::Var $node, :$want) {
         my $action;
 
+        my $type := self.figure_out_type($node);
+
         if $node.scope eq 'lexical' || $node.scope eq 'local' {
             my str $scope := $node.scope;
             if $*BINDVAL {
-                my $value := self.as_truffle_clear_bindval($*BINDVAL, :want($OBJ));
-                $action := ["bind-$scope", $node.name, $value.tree];
+                my $value := self.as_truffle_clear_bindval($*BINDVAL, :want($type));
+                $action := ["bind-{nqp::lc(%type_names{$type})}-$scope", $node.name, $value.tree];
             } else {
                 $action := ["get-$scope", $node.name];
             }
 
             if $node.decl eq '' {
-                return TAST.new($OBJ, $action);
+                return TAST.new($type, $action);
             }
             # TODO static should do deserialization
             elsif $node.decl eq 'var' || $node.decl eq 'static' {
-                return TAST.new($OBJ, ["declare-$scope", $node.name, $action]);
+                my int $type := self.type_from_typeobj($node.returns);
+                $*BLOCK.register_var_type($node, $type);
+                return TAST.new($type, ["declare-$scope", $type, $node.name, $action]);
             }
             elsif $node.decl eq 'param' {
                 $*BLOCK.add_param($node);

src/vm/jvm/runtime/org/perl6/nqp/truffle/ManageScopes.java

@@ -2,11 +2,15 @@
 
 import com.oracle.truffle.api.frame.FrameDescriptor;
 import com.oracle.truffle.api.frame.FrameSlot;
+import com.oracle.truffle.api.frame.FrameSlotKind;
 
 import org.perl6.nqp.truffle.nodes.NQPNode;
 import org.perl6.nqp.truffle.nodes.NQPBlockBodyNode;
 import org.perl6.nqp.truffle.nodes.control.NQPBlockNode;
 
+import org.perl6.nqp.truffle.MalformedAstException;
+
+
 import org.perl6.nqp.dsl.Predeserializer;
 import org.perl6.nqp.dsl.Deserializer;
 
@@ -25,25 +29,36 @@ public static NQPNode createBlock(NQPScope scope, NQPNode[] children) {
         );
     }
 
+    private static FrameSlotKind kindFromType(long type) {
+        switch ((int)type) {
+            case 0: return FrameSlotKind.Object;
+            case 1: return FrameSlotKind.Long;
+            case 2: return FrameSlotKind.Double;
+            case 3: return FrameSlotKind.Object;
+            default: throw new MalformedAstException("Wrong variable type: " + type);
+        }
+    }
+
+
     @Predeserializer("declare-lexical")
-    public static NQPScope declareLexical(NQPScope scope, String name) {
+    public static NQPScope declareLexical(NQPScope scope, long type, String name) {
         scope.addLexical(name);
         return scope;
     }
 
     @Deserializer("declare-lexical")
-    public static NQPNode createDeclareLexical(NQPScope scope, String name, NQPNode inner) {
+    public static NQPNode createDeclareLexical(NQPScope scope, long type, String name, NQPNode inner) {
         return inner;
     }
 
     @Predeserializer("declare-local")
-    public static NQPScope declareLocal(NQPScope scope, String name) {
+    public static NQPScope declareLocal(NQPScope scope, long type, String name) {
         scope.addLocal(name);
         return scope;
     }
 
     @Deserializer("declare-local")
-    public static NQPNode createDeclareLocal(NQPScope scope, String name, NQPNode inner) {
+    public static NQPNode createDeclareLocal(NQPScope scope, long type, String name, NQPNode inner) {
         return inner;
     }
 }

src/vm/jvm/runtime/org/perl6/nqp/truffle/nodes/NQPWhileNode.java

@@ -44,7 +44,7 @@ public WhileRepeatingNode(NQPNode condNode, NQPNode bodyNode) {
         public boolean executeRepeating(VirtualFrame frame) {
             if (toBoolean(condNode.execute(frame))) {
                 try {
-                    bodyNode.execute(frame);
+                    bodyNode.executeVoid(frame);
                 } catch (ContinueException ex) {
                     // the body might throw a continue control-flow exception
                     // continue loop invocation

src/vm/jvm/runtime/org/perl6/nqp/truffle/nodes/variables/NQPBindIntVariableNode.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package org.perl6.nqp.truffle.nodes.variables;
+
+import com.oracle.truffle.api.frame.FrameSlot;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import org.perl6.nqp.truffle.nodes.NQPNode;
+
+import org.perl6.nqp.dsl.Deserializer;
+
+import org.perl6.nqp.truffle.NQPScope;
+import org.perl6.nqp.truffle.FoundLexical;
+
+public class NQPBindIntVariableNode extends FrameLookupNode {
+    final private FrameSlot slot;
+    @Child private NQPNode valueNode;
+
+    public NQPBindIntVariableNode(FrameSlot slot, int depth, NQPNode valueNode) {
+        super(depth);
+        this.slot = slot;
+        this.valueNode = valueNode;
+    }
+
+    @Override
+    public long executeInt(VirtualFrame frame) {
+        long value = valueNode.executeInt(frame);
+        getFrame(frame).setLong(slot, value);
+        return value;
+    }
+
+    @Deserializer("bind-int-lexical")
+    public static NQPBindIntVariableNode bindLexical(NQPScope scope, String name, NQPNode valueNode) {
+        FoundLexical foundLexical = scope.findLexical(name);
+        return new NQPBindIntVariableNode(foundLexical.getFrameSlot(), foundLexical.getDepth(), valueNode);
+    }
+
+    @Deserializer("bind-int-local")
+    public static NQPBindIntVariableNode bindLocal(NQPScope scope, String name, NQPNode valueNode) {
+        return new NQPBindIntVariableNode(scope.findLocal(name), 0, valueNode);
+    }
+
+    @Override 
+    public void executeVoid(VirtualFrame frame) {
+        executeInt(frame);
+    }
+}

src/vm/jvm/runtime/org/perl6/nqp/truffle/nodes/variables/NQPBindNumVariableNode.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package org.perl6.nqp.truffle.nodes.variables;
+
+import com.oracle.truffle.api.frame.FrameSlot;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import org.perl6.nqp.truffle.nodes.NQPNode;
+
+import org.perl6.nqp.dsl.Deserializer;
+
+import org.perl6.nqp.truffle.NQPScope;
+import org.perl6.nqp.truffle.FoundLexical;
+
+public class NQPBindNumVariableNode extends FrameLookupNode {
+    final private FrameSlot slot;
+    @Child private NQPNode valueNode;
+
+    public NQPBindNumVariableNode(FrameSlot slot, int depth, NQPNode valueNode) {
+        super(depth);
+        this.slot = slot;
+        this.valueNode = valueNode;
+    }
+
+    @Override
+    public double executeNum(VirtualFrame frame) {
+        double value = valueNode.executeNum(frame);
+        getFrame(frame).setDouble(slot, value);
+        return value;
+    }
+
+    @Deserializer("bind-num-lexical")
+    public static NQPBindNumVariableNode bindLexical(NQPScope scope, String name, NQPNode valueNode) {
+        FoundLexical foundLexical = scope.findLexical(name);
+        return new NQPBindNumVariableNode(foundLexical.getFrameSlot(), foundLexical.getDepth(), valueNode);
+    }
+
+    @Deserializer("bind-num-local")
+    public static NQPBindNumVariableNode bindLocal(NQPScope scope, String name, NQPNode valueNode) {
+        return new NQPBindNumVariableNode(scope.findLocal(name), 0, valueNode);
+    }
+
+    @Override 
+    public void executeVoid(VirtualFrame frame) {
+        executeNum(frame);
+    }
+}