jievro-parser 0.4.0

data/lib/parser/grammar/expression/closure_expression.treetop

@@ -0,0 +1,188 @@
+module Kauri
+  grammar ClosureExpression
+
+    rule closure_expression
+      '{' ws1:_ closure_signature:closure_signature? ws2:_ statement_list:statement_list ws3:_ '}' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPEN_CURLY_BRACKET',
+            value: '{'
+          })
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          unless closure_signature.text_value.empty?
+            tokens.concat(closure_signature.tokens)
+          end
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.concat(statement_list.tokens)
+
+          unless ws3.text_value.empty?
+            tokens.concat(ws3.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_CURLY_BRACKET',
+            value: '}'
+          })
+
+          tokens
+        end
+
+        def ast
+
+          ast = {
+            block_type: 'closure-expression',
+            body: statement_list.ast
+          }
+
+          unless closure_signature.text_value.empty?
+            ast[:signature] = closure_signature.ast
+          end
+
+          [ast]
+        end
+      }
+    end
+
+    rule closure_signature
+      capture_list:capture_list ws:whitespaces 'in' {
+        def tokens
+          tokens = []
+
+          tokens.concat(capture_list.tokens)
+          tokens.concat(ws.tokens)
+
+          tokens.push({
+            type: 'T_IN',
+            value: 'in'
+          })
+
+          tokens
+        end
+
+        def ast
+          capture_list.ast
+        end
+      }
+    end
+
+    rule capture_list
+      '[' ws1:_ capture_specifier:capture_specifier ws2:_ expression:expression ws3:_ ']' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPEN_SQUARE_BRACKET',
+            value: '['
+          })
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.concat(capture_specifier.tokens)
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.concat(expression.tokens)
+
+          unless ws3.text_value.empty?
+            tokens.concat(ws3.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_SQUARE_BRACKET',
+            value: ']'
+          })
+
+          tokens
+        end
+
+        def ast
+          {
+            capture: {
+              specifier: capture_specifier.ast,
+              expression: expression.ast.first
+            }
+          }
+        end
+      }
+    end
+
+    rule capture_specifier
+      unowned_safe_or_unsafe_capture_specifier / weak_or_unowned_capture_specifier
+    end
+
+    rule weak_or_unowned_capture_specifier
+      ('weak' / 'unowned') {
+        def tokens
+          [{
+            type: 'T_' + text_value.upcase,
+            value: text_value
+          }]
+        end
+
+        def ast
+          text_value
+        end
+      }
+    end
+
+    rule unowned_safe_or_unsafe_capture_specifier
+      'unowned' ws1:_ '(' ws2:_ safe_or_unsafe:('safe' / 'unsafe') ws3:_ ')' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_UNOWNED',
+            value: 'unowned'
+          })
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.push({
+            type: 'T_OPEN_ROUND_BRACKET',
+            value: '('
+          })
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.push({
+            type: 'T_' + safe_or_unsafe.text_value.upcase,
+            value: safe_or_unsafe.text_value
+          })
+
+          unless ws3.text_value.empty?
+            tokens.concat(ws3.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_ROUND_BRACKET',
+            value: ')'
+          })
+
+          tokens
+        end
+
+        def ast
+          'unowned' + '-' + safe_or_unsafe.text_value
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/expression/expression.treetop

@@ -0,0 +1,83 @@
+require 'parser/grammar/expression/literal_expression'
+require 'parser/grammar/expression/prefix_expression'
+require 'parser/grammar/expression/postfix_expression'
+require 'parser/grammar/expression/binary_expression'
+require 'parser/grammar/expression/range_expression'
+require 'parser/grammar/expression/primary_expression'
+require 'parser/grammar/expression/parenthesized_expression'
+require 'parser/grammar/expression/wildcard_expression'
+require 'parser/grammar/expression/function_call_expression'
+require 'parser/grammar/expression/closure_expression'
+require 'parser/grammar/expression/self_expression'
+require 'parser/grammar/expression/super_expression'
+
+module Kauri
+  grammar Expression
+
+    include Kauri::LiteralExpression
+    include Kauri::PrefixExpression
+    include Kauri::PostfixExpression
+    include Kauri::BinaryExpression
+    include Kauri::RangeExpression
+    include Kauri::PrimaryExpression
+    include Kauri::ParenthesizedExpression
+    include Kauri::WildcardExpression
+    include Kauri::FunctionCallExpression
+    include Kauri::ClosureExpression
+    include Kauri::SelfExpression
+    include Kauri::SuperExpression
+
+    rule expression
+      super_expression
+      /
+      self_expression
+      /
+      closure_expression
+      /
+      function_call_expression
+      /
+      binary_expression
+      /
+      range_expression
+      /
+      primary_expression
+      /
+      prefix_expression
+    end
+
+    rule expression_list
+      head:(expression:expression ws1:_ ',' ws2:_)* tail:expression {
+        def tokens
+          tokens = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+              tokens.concat(e.expression.tokens)
+              tokens.concat(e.ws1.tokens) unless e.ws1.text_value.empty?
+              tokens.push(T_COMMA)
+              tokens.concat(e.ws2.tokens) unless e.ws2.text_value.empty?
+            }
+          end
+
+          tokens.concat(tail.tokens)
+
+          tokens
+        end
+
+        def ast
+          ast = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+              ast.concat(e.expression.ast)
+            }
+          end
+
+          ast.concat(tail.ast)
+
+          ast
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/expression/function_call_expression.treetop

@@ -0,0 +1,32 @@
+module Kauri
+  grammar FunctionCallExpression
+
+    rule function_call_expression
+      callee:postfix_expression ws:_ parameters:parenthesized_expression {
+        def tokens
+          tokens = []
+
+          tokens.concat(callee.tokens)
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          tokens.concat(parameters.tokens)
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              block_type: 'function-call-expression',
+              callee: callee.ast.first,
+              parameters: parameters.ast
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/expression/literal_expression.treetop

@@ -0,0 +1,8 @@
+module Kauri
+  grammar LiteralExpression
+
+    rule literal_expression
+      literal
+    end
+  end
+end

data/lib/parser/grammar/expression/parenthesized_expression.treetop

@@ -0,0 +1,146 @@
+module Kauri
+  grammar ParenthesizedExpression
+
+    rule parenthesized_expression
+      '(' ws1:_ expression:expression_element_list? ws2:_ ')' {
+        def tokens
+
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPEN_ROUND_BRACKET',
+            value: '('
+          })
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          unless expression.text_value.empty?
+            tokens.concat(expression.tokens)
+          end
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_ROUND_BRACKET',
+            value: ')'
+          })
+
+          tokens
+        end
+
+        def ast
+          ast = []
+
+          unless expression.text_value.empty?
+            ast = expression.ast
+          end
+
+          ast
+        end
+      }
+    end
+
+    rule expression_element_list
+      head:(expression:expression_element ws1:_ ',' ws2:_)* tail:expression_element {
+        def tokens
+          tokens = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+
+              tokens.concat(e.expression.tokens)
+
+              unless e.ws1.text_value.empty?
+                tokens.concat(e.ws1.tokens)
+              end
+
+              tokens.push({
+                type: 'T_COMMA',
+                value: ','
+              })
+
+              unless e.ws2.text_value.empty?
+                tokens.concat(e.ws2.tokens)
+              end
+            }
+          end
+
+          tokens.concat(tail.tokens)
+
+          tokens
+        end
+
+        def ast
+          ast = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+              ast.concat(e.expression.ast)
+            }
+          end
+
+          ast.concat(tail.ast)
+
+          ast
+        end
+      }
+    end
+
+    rule expression_element
+      expression_element_with_identifier / only_expression
+    end
+
+    rule only_expression
+      expression:expression {
+        def tokens
+          expression.tokens
+        end
+
+        def ast
+          expression.ast
+        end
+      }
+    end
+
+    rule expression_element_with_identifier
+      identifier:identifier ws1:_ ':' ws2:_ expression:expression {
+        def tokens
+          tokens = []
+
+          tokens.concat(identifier.tokens)
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.push({
+            type: 'T_COLON',
+            value: ':'
+          })
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.concat(expression.tokens)
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              block_type: 'expression-element',
+              identifier: identifier.ast.first,
+              expression: expression.ast.first
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/expression/postfix_expression.treetop

@@ -0,0 +1,8 @@
+module Kauri
+  grammar PostfixExpression
+
+    rule postfix_expression
+      primary_expression
+    end
+  end
+end

data/lib/parser/grammar/expression/prefix_expression.treetop

@@ -0,0 +1,29 @@
+module Kauri
+  grammar PrefixExpression
+
+    rule prefix_expression
+      operator:prefix_operator expression:postfix_expression {
+        def tokens
+          [
+            operator.tokens.first,
+            expression.tokens.first
+          ]
+        end
+
+        def ast
+          [
+            {
+              block_type: 'prefix-expression',
+              operator: operator.operator,
+              argument: expression.ast.first
+            }
+          ]
+        end
+      }
+    end
+
+    rule prefix_operator
+      operator
+    end
+  end
+end

data/lib/parser/grammar/expression/primary_expression.treetop

@@ -0,0 +1,8 @@
+module Kauri
+  grammar PrimaryExpression
+
+    rule primary_expression
+      parenthesized_expression / literal_expression / wildcard_expression / identifier
+    end
+  end
+end

data/lib/parser/grammar/expression/range_expression.treetop

@@ -0,0 +1,53 @@
+module Kauri
+  grammar RangeExpression
+
+    rule range_expression
+      left:primary_expression ws1:_ range_operator:range_operator ws2:_ right:primary_expression {
+        def tokens
+
+          tokens = []
+
+          tokens.concat(left.tokens)
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.concat(range_operator.tokens)
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.concat(right.tokens)
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              block_type: 'binary-expression',
+              operator: range_operator.text_value,
+              left: left.ast.first,
+              right: right.ast.first
+            }
+          ]
+        end
+      }
+    end
+
+    rule range_operator
+      ('...' / '..<') {
+        def tokens
+        [
+          {
+            type: 'T_OPERATOR',
+            value: text_value
+          }
+        ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/expression/self_expression.treetop

@@ -0,0 +1,25 @@
+module Kauri
+  grammar SelfExpression
+
+    rule self_expression
+      'self' {
+        def tokens
+          [
+            {
+              type: 'T_SELF',
+              value: 'self'
+            }
+          ]
+        end
+
+        def ast
+          [
+            {
+              block_type: 'self-expression'
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/expression/super_expression.treetop

@@ -0,0 +1,25 @@
+module Kauri
+  grammar SuperExpression
+
+    rule super_expression
+      'super' {
+        def tokens
+          [
+            {
+              type: 'T_SUPER',
+              value: 'super'
+            }
+          ]
+        end
+
+        def ast
+          [
+            {
+              block_type: 'super-expression'
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/expression/wildcard_expression.treetop

@@ -0,0 +1,8 @@
+module Kauri
+  grammar WildcardExpression
+
+    rule wildcard_expression
+      pattern_wildcard
+    end
+  end
+end

data/lib/parser/grammar/generics/generic_argument_clause.treetop

@@ -0,0 +1,89 @@
+module Kauri
+  grammar GenericArgumentClause
+
+    rule generic_argument_clause
+      '<' ws1:_ generic_argument_list:generic_argument_list ws2:_ '>' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPEN_ANGLE_BRACKET',
+            value: '<'
+          })
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.concat(generic_argument_list.tokens)
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_ANGLE_BRACKET',
+            value: '>'
+          })
+
+          tokens
+        end
+
+        def ast
+          generic_argument_list.ast
+        end
+      }
+    end
+
+    rule generic_argument_list
+      head:(generic_argument:generic_argument ws1:_ ',' ws2:_)* tail:generic_argument {
+        def tokens
+          tokens = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+
+              tokens.concat(e.generic_argument.tokens)
+
+              unless e.ws1.text_value.empty?
+                tokens.concat(e.ws1.tokens)
+              end
+
+              tokens.push({
+                type: 'T_COMMA',
+                value: ','
+              })
+
+              unless e.ws2.text_value.empty?
+                tokens.concat(e.ws2.tokens)
+              end
+            }
+          end
+
+          tokens.concat(tail.tokens)
+
+          tokens
+        end
+
+        def ast
+
+          ast = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+              ast.concat(e.generic_argument.ast)
+            }
+          end
+
+          ast.concat(tail.ast)
+
+          ast
+        end
+      }
+    end
+
+    rule generic_argument
+      type
+    end
+  end
+end