crystal-lang · Oct 29, 2017 · Oct 30, 2017 · Oct 31, 2017 · Nov 1, 2017 · Jan 3, 2018
Showing with 128 additions and 6 deletions.

+50 −0 spec/compiler/macro/macro_methods_spec.cr

+39 −6 src/compiler/crystal/macros.cr

+39 −0 src/compiler/crystal/macros/methods.cr
diff --git a/spec/compiler/macro/macro_methods_spec.cr b/spec/compiler/macro/macro_methods_spec.cr
@@ -1205,6 +1205,56 @@ describe "macro methods" do
     end
   end
 
+  describe "proc notation methods" do
+    it "gets single input" do
+      assert_macro "x", %({{x.inputs}}), [ProcNotation.new([Path.new("SomeType")] of ASTNode, Path.new("SomeResult"))] of ASTNode, "[SomeType]"
+    end
+
+    it "gets single output" do
+      assert_macro "x", %({{x.output}}), [ProcNotation.new([Path.new("SomeType")] of ASTNode, Path.new("SomeResult"))] of ASTNode, "SomeResult"
+    end
+
+    it "gets multiple inputs" do
+      assert_macro "x", %({{x.inputs}}), [ProcNotation.new([Path.new("SomeType"), Path.new("OtherType")] of ASTNode)] of ASTNode, "[SomeType, OtherType]"
+    end
+
+    it "gets empty output" do
+      assert_macro "x", %({{x.output}}), [ProcNotation.new([Path.new("SomeType")] of ASTNode)] of ASTNode, "nil"
+    end
+  end
+
+  describe "proc literal methods" do
+    it "executes body" do
+      assert_macro "x", %({{x.body}}), [ProcLiteral.new(Def.new("->", body: 1.int32))] of ASTNode, "1"
+    end
+
+    it "executes args" do
+      assert_macro "x", %({{x.args}}), [ProcLiteral.new(Def.new("->", args: [Arg.new("z")]))] of ASTNode, "[z]"
+    end
+  end
+
+  describe "proc pointer methods" do
+    it "executes obj when present" do
+      assert_macro "x", %({{x.obj}}), [ProcPointer.new(Var.new("some_object"), "method", [] of ASTNode)] of ASTNode, "some_object"
+    end
+
+    it "executes obj when absent" do
+      assert_macro "x", %({{x.obj}}), [ProcPointer.new(NilLiteral.new, "method", [] of ASTNode)] of ASTNode, "nil"
+    end
+
+    it "executes name" do
+      assert_macro "x", %({{x.name}}), [ProcPointer.new(Var.new("some_object"), "method", [] of ASTNode)] of ASTNode, "method"
+    end
+
+    it "executes args when empty" do
+      assert_macro "x", %({{x.args}}), [ProcPointer.new(Var.new("some_object"), "method", [] of ASTNode)] of ASTNode, "[]"
+    end
+
+    it "executes args when not empty" do
+      assert_macro "x", %({{x.args}}), [ProcPointer.new(Var.new("some_object"), "method", [Path.new("SomeType"), Path.new("OtherType")] of ASTNode)] of ASTNode, "[SomeType, OtherType]"
+    end
+  end
+
   describe "def methods" do
     it "executes name" do
       assert_macro "x", %({{x.name}}), [Def.new("some_def")] of ASTNode, "some_def"

diff --git a/src/compiler/crystal/macros.cr b/src/compiler/crystal/macros.cr
@@ -965,8 +965,16 @@ module Crystal::Macros
     end
   end
 
-  # class ProcNotation < ASTNode
-  # end
+  # The type of a proc or block argument, like `String -> Int32`.
+  class ProcNotation < ASTNode
+    # Returns the argument types, or an empty list if no arguments.
+    def inputs : ArrayLiteral(ASTNode)
+    end
+
+    # Returns the output type, or nil if there is no return type.
+    def output : ASTNode | NilLiteral
+    end
+  end
 
   # A method definition.
   class Def < ASTNode
@@ -1236,11 +1244,36 @@ module Crystal::Macros
   # class ExceptionHandler < ASTNode
   # end
 
-  # class ProcLiteral < ASTNode
-  # end
+  # A proc method, written like:
+  # ```
+  # ->(arg : String) {
+  #   puts arg
+  # }
+  # ```
+  class ProcLiteral < ASTNode
+    # Returns the arguments of this proc.
+    def args : ArrayLiteral(Arg)
+    end
 
-  # class ProcPointer < ASTNode
-  # end
+    # Returns the body of this proc.
+    def body : ASTNode
+    end
+  end
+
+  # A proc pointer, like `->my_var.some_method(String)`
+  class ProcPointer < ASTNode
+    # Returns the types of the arguments of the proc.
+    def args : ArrayLiteral(ASTNode)
+    end
+
+    # Returns the receiver of the proc, or nil if the proc is not attached to an object.
+    def obj : ASTNode | NilLiteral
+    end
+
+    # Returns the name of the method this proc points to.
+    def name : MacroId
+    end
+  end
 
   # A type union, like `(Int32 | String)`.
   class Union < ASTNode

diff --git a/src/compiler/crystal/macros/methods.cr b/src/compiler/crystal/macros/methods.cr
@@ -1084,6 +1084,45 @@ module Crystal
     end
   end
 
+  class ProcNotation
+    def interpret(method, args, block, interpreter)
+      case method
+      when "inputs"
+        interpret_argless_method(method, args) { ArrayLiteral.new(@inputs || [] of ASTNode) }
+      when "output"
+        interpret_argless_method(method, args) { @output || NilLiteral.new }
+      else
+        super
+      end
+    end
+  end
+
+  class ProcLiteral
+    def interpret(method, args, block, interpreter)
+      case method
+      when "args", "body"
+        @def.interpret(method, args, block, interpreter)
+      else
+        super
+      end
+    end
+  end
+
+  class ProcPointer
+    def interpret(method, args, block, interpreter)
+      case method
+      when "obj"
+        interpret_argless_method(method, args) { @obj || NilLiteral.new }
+      when "name"
+        interpret_argless_method(method, args) { MacroId.new(@name) }
+      when "args"
+        interpret_argless_method(method, args) { ArrayLiteral.new(@args) }
+      else
+        super
+      end
+    end
+  end
+
   class Expressions
     def interpret(method, args, block, interpreter)
       case method