IR: add support for ReScript array.

rift-engine/rift/ir/IR.py

@@ -209,6 +209,7 @@ def __str__(self) -> str:
 
 
 SymbolKindName = Literal[
+ "Array",
  "Body",
  "Call",
  "Class",
@@ -278,6 +279,26 @@ class MetaSymbolKind(SymbolKind):
  pass
 
 
+@dataclass
+class ArrayKind(MetaSymbolKind):
+ """A symbol kind representing an array expression."""
+
+ elements: List[Expression]
+
+ @property
+ def kind(self) -> SymbolKindName:
+ return "Array"
+
+ def dump(self, lines: List[str]) -> None:
+ lines.append(f" elements: {self.elements}")
+
+ def __str__(self) -> str:
+ return f"[{', '.join(self.elements)}]"
+
+ def __repr__(self) -> str:
+ return self.__str__()
+
+
 @dataclass
 class BodyKind(MetaSymbolKind):
  """Represents the body of a branch in the intermediate representation (IR).

rift-engine/rift/ir/parser_lean.py

@@ -1,15 +1,9 @@
 import logging
 from typing import List
 
-
 from rift.ir.parser_core import Counter, SymbolParser
 
-from .IR import (
- DefKind,
- StructureKind,
- Symbol,
- TheoremKind,
-)
+from .IR import DefKind, StructureKind, Symbol, TheoremKind
 
 logger = logging.getLogger(__name__)
 

rift-engine/rift/ir/parser_ocaml.py

@@ -4,14 +4,7 @@
 
 from rift.ir.parser_core import Counter, SymbolParser
 
-from .IR import (
- FunctionKind,
- ModuleKind,
- Parameter,
- Symbol,
- Type,
- ValueKind,
-)
+from .IR import FunctionKind, ModuleKind, Parameter, Symbol, Type, ValueKind
 
 
 class OCamlParser(SymbolParser):

rift-engine/rift/ir/parser_rescript.py

@@ -1,12 +1,15 @@
 import logging
+import os
 from typing import List, Optional
 
 from tree_sitter import Node
 
 from rift.ir.parser_core import Counter, SymbolParser
 
 from .IR import (
+ ArrayKind,
  Case,
+ Expression,
  Field,
  FunctionKind,
  IfKind,
@@ -345,12 +348,36 @@ def parse_metasymbol(self, counter: Counter) -> Optional[Symbol]:
  self.file.add_symbol(switch_symbol)
  return switch_symbol
 
+ elif node.type == "array":
+ symbol = self.mk_dummy_metasymbol(counter, "array")
+ elements: List[Expression] = []
+ symbol_kind = ArrayKind(symbol, elements)
+ for child in self.node.children:
+ if child.type in ["[", "]", ","]:
+ continue
+ scope = self.scope
+ exp = self.recurse(child, scope, parent=symbol).parse_expression(counter)
+ elements.append(exp)
+ self.update_dummy_symbol(symbol, symbol_kind)
+ self.file.add_symbol(symbol)
+ return symbol
+
  return super().parse_metasymbol(counter)
 
  def walk_expression(self, counter: Counter) -> None:
- if self.node.type in ["if_expression", "switch_expression"]:
+ if self.node.type in ["if_expression", "switch_expression", "array"]:
  self.parse_symbols(counter)
  elif self.node.type == "block":
  self.parse_block()
 
  super().walk_expression(counter)
+
+
+def test():
+ from . import custom_parsers, parser
+
+ project_root = os.path.join(os.path.dirname(__file__), "tests")
+ custom_parsers.activate()
+ project = parser.parse_files_in_paths([project_root], metasymbols=True)
+ map = project.dump_map(indent=0)
+ print(f"\nMAP:\n{map}")

rift-engine/rift/ir/tests/record.res

@@ -7,5 +7,5 @@ let useInConditional = x => {
 }
 
 let useAtToplevel = x => {
- useState()
+ useState([1,2,[3,4]])
 }