Support Function Calls

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
2026-04-09 23:16:27 -04:00
parent 708f65a0a9
commit d39127ac17
21 changed files with 984 additions and 311 deletions
@@ -0,0 +1,318 @@
+// p4rse, Copyright 2026, Will Hawkins
+//
+// This file is part of p4rse.
+//
+// This file is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import Common
+import P4Lang
+import P4Runtime
+import SwiftTreeSitter
+import TreeSitterExtensions
+import TreeSitterP4
+
+func parameter_list_compiler(
+  node: SwiftTreeSitter.Node, withContext context: CompilerContext
+) -> Common.Result<(ParameterList, CompilerContext)> {
+
+  var currentChildIdx = 0
+  var currentChildIdxSafe = 1
+  var currentChild: Node? = .none
+
+  if node.text == ")" {
+    // There are no parameters!
+    return Result.Ok((ParameterList([]), context))
+  }
+
+  #RequireNodeType<Node, (ParameterList, CompilerContext)>(
+    node: node, type: "parameter_list", nice_type_name: "Parameter List")
+
+  var parameters: ParameterList = ParameterList([])
+
+  if node.childCount < currentChildIdxSafe {
+    return Result.Error(
+      ErrorOnNode(node: node, withError: "Missing parameter list component"))
+  }
+
+  currentChild = node.child(at: currentChildIdx)
+  if currentChild?.nodeType == "parameter_list" {
+    switch parameter_list_compiler(node: currentChild!, withContext: context) {
+    case .Ok(let (ps, _)):
+      parameters = ps
+    case .Error(let e): return Result.Error(e)
+    }
+
+    currentChildIdx += 1
+    currentChildIdxSafe += 1
+  }
+
+  // We may have moved nodes, check/reset currentChild.
+  if node.childCount < currentChildIdxSafe {
+    return Result.Error(
+      ErrorOnNode(node: node, withError: "Missing parameter list component"))
+  }
+  currentChild = node.child(at: currentChildIdx)
+
+  // If this is a ')', we are done.
+  if currentChild?.text == ")" {
+    return Result.Ok((parameters, context))
+  }
+
+  // If this is a comma, we skip it!
+  if currentChild?.text == "," {
+    currentChildIdx += 1
+    currentChildIdxSafe += 1
+  }
+
+  if node.childCount < currentChildIdxSafe {
+    return Result.Error(
+      ErrorOnNode(node: node, withError: "Missing parameter list component"))
+  }
+  currentChild = node.child(at: currentChildIdx)
+
+  // Otherwise, there should be one parameter left!
+  switch Parameter.Compile(node: currentChild!, withContext: context) {
+  case .Ok(let (vds, updated_context)):
+    return Result.Ok((parameters.addParameter(vds), updated_context))
+  case .Error(let e): return Result.Error(e)
+  }
+}
+
+extension ParameterList: Compilable {
+  public typealias T = ParameterList
+  public static func Compile(
+    node: SwiftTreeSitter.Node, withContext context: CompilerContext
+  ) -> Common.Result<(ParameterList, CompilerContext)> {
+
+    let parameter_node = node
+    #RequireNodeType<Node, (ParameterList, CompilerContext)>(
+      node: parameter_node, type: "parameters", nice_type_name: "Parameters")
+
+    var currentChildIdx = 0
+    var currentChildIdxSafe = 1
+
+    // Let's eat the '(' before we start ...
+    if parameter_node.childCount < currentChildIdxSafe {
+      return .Error(
+        ErrorOnNode(node: parameter_node, withError: "Missing '(' in parameter list component"))
+    }
+
+    currentChildIdx += 1
+    currentChildIdxSafe += 1
+    if parameter_node.childCount < currentChildIdxSafe {
+      return .Error(
+        ErrorOnNode(node: parameter_node, withError: "Missing parameter list component"))
+    }
+    let currentChild = parameter_node.child(at: currentChildIdx)
+
+    return parameter_list_compiler(node: currentChild!, withContext: context)
+  }
+}
+
+extension Parameter: Compilable {
+  public typealias T = Parameter
+  public static func Compile(
+    node: Node, withContext context: CompilerContext
+  ) -> Result<(Parameter, CompilerContext)> {
+
+    #RequireNodeType<Node, (EvaluatableStatement, CompilerContext)>(
+      node: node, type: "parameter", nice_type_name: "parameter")
+
+    var currentChildIdx = 0
+    var currentChildIdxSafe = 1
+    var currentChild: Node? = .none
+
+    if node.childCount < currentChildIdxSafe {
+      return .Error(
+        ErrorOnNode(node: node, withError: "Missing parameter declaration component"))
+    }
+
+    currentChild = node.child(at: currentChildIdx)
+
+    // Annotation?
+    if currentChild!.nodeType == "annotations" {
+      return .Error(
+        ErrorOnNode(
+          node: currentChild!,
+          withError: "Annotations in parameter declarations are not yet handled"))
+      // Will increment indexes here.
+    }
+
+    // Direction?
+    if currentChild!.nodeType == "direction" {
+      return .Error(
+        ErrorOnNode(
+          node: currentChild!, withError: "Direction in parameter declarations are not yet handled"
+        ))
+      // Will increment indexes here.
+    }
+
+    if currentChild!.nodeType != "typeRef" {
+      return Result.Error(
+        ErrorOnNode(
+          node: node, withError: "Did not find type name for parameter declaration"))
+    }
+
+    guard
+      case .Ok(let parameter_type) = Types.CompileType(type: currentChild!, withContext: context)
+    else {
+      return Result.Error(
+        Error(withMessage: "Could not parse a P4 type from \(currentChild!.text!)"))
+    }
+
+    currentChildIdx += 1
+    currentChildIdxSafe += 1
+    if node.childCount < currentChildIdxSafe {
+      return .Error(
+        ErrorOnNode(node: node, withError: "Missing parameter declaration component"))
+    }
+
+    currentChild = node.child(at: currentChildIdx)
+    if currentChild!.nodeType != "identifier" {
+      return Result.Error(
+        ErrorOnNode(
+          node: node, withError: "Did not find identifier for parameter statement"))
+    }
+
+    guard
+      case .Ok(let parameter_name) = Identifier.Compile(node: currentChild!, withContext: context)
+    else {
+      return Result.Error(
+        Error(withMessage: "Could not parse a parameter name from \(currentChild!.text!)"))
+    }
+
+    return Result.Ok(
+      (
+        Parameter(
+          identifier: parameter_name, withType: parameter_type),
+        context
+      ))
+  }
+}
+
+func argument_list_compiler(
+  node: SwiftTreeSitter.Node, withContext context: CompilerContext
+) -> Common.Result<(ArgumentList, CompilerContext)> {
+
+  var currentChildIdx = 0
+  var currentChildIdxSafe = 1
+  var currentChild: Node? = .none
+
+  if node.text == ")" {
+    // There are no arguments!
+    return Result.Ok((ArgumentList([]), context))
+  }
+
+  #RequireNodeType<Node, (ArgumentList, CompilerContext)>(
+    node: node, type: "argument_list", nice_type_name: "argument List")
+
+  var arguments: ArgumentList = ArgumentList([])
+
+  if node.childCount < currentChildIdxSafe {
+    return Result.Error(
+      ErrorOnNode(node: node, withError: "Missing argument list component"))
+  }
+
+  currentChild = node.child(at: currentChildIdx)
+  if currentChild?.nodeType == "argument_list" {
+    switch argument_list_compiler(node: currentChild!, withContext: context) {
+    case .Ok(let (ps, _)):
+      arguments = ps
+    case .Error(let e): return Result.Error(e)
+    }
+
+    currentChildIdx += 1
+    currentChildIdxSafe += 1
+  }
+
+  // We may have moved nodes, check/reset currentChild.
+  if node.childCount < currentChildIdxSafe {
+    return Result.Error(
+      ErrorOnNode(node: node, withError: "Missing argument list component"))
+  }
+  currentChild = node.child(at: currentChildIdx)
+
+  // If this is a ')', we are done.
+  if currentChild?.text == ")" {
+    return Result.Ok((arguments, context))
+  }
+
+  // If this is a comma, we skip it!
+  if currentChild?.text == "," {
+    currentChildIdx += 1
+    currentChildIdxSafe += 1
+  }
+
+  if node.childCount < currentChildIdxSafe {
+    return Result.Error(
+      ErrorOnNode(node: node, withError: "Missing argument list component"))
+  }
+  currentChild = node.child(at: currentChildIdx)
+
+  // Otherwise, there should be one argument left!
+  switch Argument.Compile(node: currentChild!, withContext: context) {
+  case .Ok(let (ce, updated_context)):
+    return Result.Ok((arguments.addArgument(Argument(ce, atIndex: arguments.count() + 1)), updated_context))
+  case .Error(let e): return Result.Error(e)
+  }
+}
+
+extension ArgumentList: Compilable {
+  public typealias T = ArgumentList
+  public static func Compile(
+    node: SwiftTreeSitter.Node, withContext context: CompilerContext
+  ) -> Common.Result<(ArgumentList, CompilerContext)> {
+
+    let argument_node = node
+    #RequireNodeType<Node, (ArgumentList, CompilerContext)>(
+      node: argument_node, type: "arguments", nice_type_name: "arguments")
+
+    var currentChildIdx = 0
+    var currentChildIdxSafe = 1
+
+    // Let's eat the '(' before we start ...
+    if argument_node.childCount < currentChildIdxSafe {
+      return .Error(
+        ErrorOnNode(node: argument_node, withError: "Missing '(' in argument list component"))
+    }
+
+    currentChildIdx += 1
+    currentChildIdxSafe += 1
+    if argument_node.childCount < currentChildIdxSafe {
+      return .Error(
+        ErrorOnNode(node: argument_node, withError: "Missing argument list component"))
+    }
+    let currentChild = argument_node.child(at: currentChildIdx)
+
+    return argument_list_compiler(node: currentChild!, withContext: context)
+  }
+}
+
+extension Argument: Compilable {
+  public typealias T = EvaluatableExpression
+  public static func Compile(
+    node: SwiftTreeSitter.Node, withContext context: CompilerContext
+  ) -> Common.Result<(EvaluatableExpression, CompilerContext)> {
+    let argument_node = node
+    #RequireNodeType<Node, (EvaluatableExpression, CompilerContext)>(
+      node: argument_node, type: "argument", nice_type_name: "argument")
+
+    let expression_node = node.child(at: 0)!
+
+    return switch Expression.Compile(node: expression_node, withContext: context) {
+        case .Ok(let compiled_expression): .Ok((compiled_expression, context))
+        case .Error(let e): .Error(e)
+    }
+  }
+}