hawkinsw/gp4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Work On Derived Types

Browse Source 
1. Add support for field access
2. Add support for proper type checking of array access
3. Add tests for nested field and array access

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
This commit is contained in:
Will Hawkins
2026-03-16 08:31:16 -04:00
parent 8ee20fcf9f
commit 2fd5ecf8d6
10 changed files with 629 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tests/p4rseTests/ScopeTests.swift
+10 -10
View File
@@ -28,39 +28,39 @@ import TreeSitterP4
@Test func test_scope() async throws {
let s = LexicalScope()
let s2 = s.declare(identifier: Identifier(name: "first"), withValue: P4Int.create())
let s2 = s.declare(identifier: Identifier(name: "first"), withValue: P4Int())
let found_first = try! #require(s2.lookup(identifier: Identifier(name: "first")))
#expect(found_first.eq(rhs: P4Int.create()))
#expect(found_first.eq(rhs: P4Int()))
#expect(s2.count == 1)
}
@Test func test_scope_no_set() async throws {
var ss = LexicalScopes().enter()
ss = ss.declare(identifier: Identifier(name: "first"), withValue: P4Int.create())
ss = ss.declare(identifier: Identifier(name: "first"), withValue: P4Int())
ss = ss.enter()
ss = ss.declare(identifier: Identifier(name: "second"), withValue: P4Boolean.create())
ss = ss.declare(identifier: Identifier(name: "second"), withValue: P4Boolean())
let found_first = try! #UseOkResult(ss.lookup(identifier: Identifier(name: "first")))
let found_second = try! #UseOkResult(ss.lookup(identifier: Identifier(name: "second")))
#expect(found_first.eq(rhs: P4Int.create()))
#expect(found_second.eq(rhs: P4Boolean.create()))
#expect(found_first.eq(rhs: P4Int()))
#expect(found_second.eq(rhs: P4Boolean()))
}
@Test func test_scope_set() async throws {
var ss = LexicalScopes().enter()
let id = Identifier(name: "first")
let id_type = P4Int.create()
let id_type = P4Int()
ss = ss.declare(identifier: id, withValue: id_type)
ss = ss.enter()
ss = ss.declare(identifier: Identifier(name: "second"), withValue: P4Boolean.create())
ss = ss.declare(identifier: Identifier(name: "second"), withValue: P4Boolean())
// Change the value of `first`.
ss = ss.set(identifier: id, withValue: P4String.create())
ss = ss.set(identifier: id, withValue: P4String())
// Verify the change!
let found = try! #UseOkResult(ss.lookup(identifier: id))
#expect(found.eq(rhs: P4String.create()))
#expect(found.eq(rhs: P4String()))
}
Tests/p4rseTests/TypeTests.swift
+38
View File
@@ -0,0 +1,38 @@
// 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 Foundation
import Common
import Macros
import SwiftTreeSitter
import Testing
import TreeSitter
import TreeSitterP4
@testable import P4Compiler
@Test func test_simple_struct() async throws {
let fields = P4StructFields([
P4StructFieldIdentifier(name: "yesno", withType: P4Boolean()),
P4StructFieldIdentifier(name: "count", withType: P4Int()),
])
let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields)
#expect(struct_type.fields.count() == 2)
#expect(struct_type.fields == fields)
}
Tests/p4rseTests/ValueTypeParserTests.swift
+322 -4
View File
@@ -230,6 +230,30 @@ import TreeSitterP4
#expect(state_result == P4Lang.reject)
}
@Test func test_expression_in_declaration_initializer_invalid_types2() async throws {
let simple_parser_declaration = """
parser main_parser() {
state start {
bool where_to = ta[0];
transition select (where_to) {
true: accept;
false: reject;
};
}
};
"""
var test_types = LexicalScopes().enter()
test_types = test_types.declare(identifier: Identifier(name: "ta"), withValue: P4Array(withValueType: P4Int()))
#expect(
#RequireErrorResult(
Error(
withMessage:
"{49, 22}: Failed to parse a statement element: Cannot initialize where_to (with type Boolean) from rvalue with type Int"
),
Program.Compile(simple_parser_declaration, withGlobalTypes: test_types)))
}
@Test func test_array_access() async throws {
let simple_parser_declaration = """
parser main_parser() {
@@ -243,11 +267,11 @@ import TreeSitterP4
};
"""
var test_types = LexicalScopes().enter()
test_types = test_types.declare(identifier: Identifier(name: "ta"), withValue: P4Array.create())
test_types = test_types.declare(identifier: Identifier(name: "ta"), withValue: P4Array(withValueType: P4Int()))
var test_values = ValueScopes().enter()
test_values = test_values.declare(
identifier: Identifier(name: "ta"),
withValue: P4ArrayValue(withValue: [
withValue: P4ArrayValue(withType: P4Int(), withValue: [
P4IntValue(withValue: 1), P4IntValue(withValue: 2), P4IntValue(withValue: 3),
]))
let program = try #UseOkResult(
@@ -258,6 +282,29 @@ import TreeSitterP4
#expect(state_result == P4Lang.accept)
}
@Test func test_array_access_invalid_type() async throws {
let simple_parser_declaration = """
parser main_parser() {
state start {
bool where_to = ta[1];
transition select (where_to) {
true: accept;
false: reject;
};
}
};
"""
var test_types = LexicalScopes().enter()
test_types = test_types.declare(identifier: Identifier(name: "ta"), withValue: P4Int())
#expect(
#RequireErrorResult(
Error(
withMessage: "{49, 22}: Failed to parse a statement element: {65, 2}: ta does not name an array type"
),
Program.Compile(simple_parser_declaration, withGlobalTypes: test_types))
)
}
@Test func test_array_access2() async throws {
let simple_parser_declaration = """
parser main_parser() {
@@ -271,11 +318,11 @@ import TreeSitterP4
};
"""
var test_types = LexicalScopes().enter()
test_types = test_types.declare(identifier: Identifier(name: "ta"), withValue: P4Array.create())
test_types = test_types.declare(identifier: Identifier(name: "ta"), withValue: P4Array(withValueType: P4Int()))
var test_values = ValueScopes().enter()
test_values = test_values.declare(
identifier: Identifier(name: "ta"),
withValue: P4ArrayValue(withValue: [
withValue: P4ArrayValue(withType: P4Int(), withValue: [
P4IntValue(withValue: 1), P4IntValue(withValue: 2), P4IntValue(withValue: 3),
]))
let program = try #UseOkResult(
@@ -285,3 +332,274 @@ import TreeSitterP4
#expect(state_result == P4Lang.reject)
}
@Test func test_array_access3() async throws {
let simple_parser_declaration = """
parser main_parser() {
state start {
transition select (ta[0] == 1) {
true: accept;
false: reject;
};
}
};
"""
var test_types = LexicalScopes().enter()
test_types = test_types.declare(identifier: Identifier(name: "ta"), withValue: P4Array(withValueType: P4Int()))
var test_values = ValueScopes().enter()
test_values = test_values.declare(
identifier: Identifier(name: "ta"),
withValue: P4ArrayValue(withType: P4Int(), withValue: [
P4IntValue(withValue: 1), P4IntValue(withValue: 2), P4IntValue(withValue: 3),
]))
let program = try #UseOkResult(
Program.Compile(simple_parser_declaration, withGlobalTypes: test_types))
let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withInitialValues: test_values))
let (state_result, _) = try! #UseOkResult(runtime.run())
#expect(state_result == P4Lang.accept)
}
@Test func test_array_access4() async throws {
let simple_parser_declaration = """
parser main_parser() {
state start {
transition select (ta[1] == 2) {
true: accept;
false: reject;
};
}
};
"""
var test_types = LexicalScopes().enter()
test_types = test_types.declare(identifier: Identifier(name: "ta"), withValue: P4Array(withValueType: P4Int()))
var test_values = ValueScopes().enter()
test_values = test_values.declare(
identifier: Identifier(name: "ta"),
withValue: P4ArrayValue(withType: P4Int(), withValue: [
P4IntValue(withValue: 1), P4IntValue(withValue: 2), P4IntValue(withValue: 3),
]))
let program = try #UseOkResult(
Program.Compile(simple_parser_declaration, withGlobalTypes: test_types))
let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withInitialValues: test_values))
let (state_result, _) = try! #UseOkResult(runtime.run())
#expect(state_result == P4Lang.accept)
}
@Test func test_array_access_nested() async throws {
let simple_parser_declaration = """
parser main_parser() {
state start {
int where_to = ta[0][0];
transition select (where_to == 5) {
true: accept;
false: reject;
};
}
};
"""
var test_types = LexicalScopes().enter()
test_types = test_types.declare(identifier: Identifier(name: "ta"), withValue: P4Array(withValueType: P4Array(withValueType: P4Int())))
var test_values = ValueScopes().enter()
let nested = P4ArrayValue(
withType: P4Int(),
withValue: [P4IntValue(withValue: 5), P4IntValue(withValue: 2), P4IntValue(withValue: 3)])
test_values = test_values.declare(
identifier: Identifier(name: "ta"),
withValue: P4ArrayValue(withType: P4Array(withValueType: P4Int()), withValue: [nested]))
let program = try #UseOkResult(
Program.Compile(simple_parser_declaration, withGlobalTypes: test_types))
let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withInitialValues: test_values))
let (state_result, _) = try! #UseOkResult(runtime.run())
#expect(state_result == P4Lang.accept)
}
@Test func test_field_access() async throws {
let simple_parser_declaration = """
parser main_parser() {
state start {
bool where_to = ts.yesno;
transition select (where_to) {
true: accept;
false: reject;
};
}
};
"""
var test_types = LexicalScopes().enter()
let fields = P4StructFields([
P4StructFieldIdentifier(name: "yesno", withType: P4Boolean()),
P4StructFieldIdentifier(name: "count", withType: P4Int()),
])
let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields)
test_types = test_types.declare(identifier: Identifier(name: "ts"), withValue: struct_type)
var test_values = ValueScopes().enter()
test_values = test_values.declare(
identifier: Identifier(name: "ts"),
withValue: P4StructValue(withType: struct_type, andInitializers: [
P4BooleanValue(withValue: true),
P4IntValue(withValue: 5),
]))
let program = try #UseOkResult(
Program.Compile(simple_parser_declaration, withGlobalTypes: test_types))
let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withInitialValues: test_values))
let (state_result, _) = try! #UseOkResult(runtime.run())
#expect(state_result == P4Lang.accept)
}
@Test func test_field_access_opp() async throws {
let simple_parser_declaration = """
parser main_parser() {
state start {
bool where_to = ts.yesno;
transition select (where_to) {
true: accept;
false: reject;
};
}
};
"""
var test_types = LexicalScopes().enter()
let fields = P4StructFields([
P4StructFieldIdentifier(name: "yesno", withType: P4Boolean()),
P4StructFieldIdentifier(name: "count", withType: P4Int()),
])
let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields)
test_types = test_types.declare(identifier: Identifier(name: "ts"), withValue: struct_type)
var test_values = ValueScopes().enter()
test_values = test_values.declare(
identifier: Identifier(name: "ts"),
withValue: P4StructValue(withType: struct_type, andInitializers: [
P4BooleanValue(withValue: false),
P4IntValue(withValue: 5),
]))
let program = try #UseOkResult(
Program.Compile(simple_parser_declaration, withGlobalTypes: test_types))
let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withInitialValues: test_values))
let (state_result, _) = try! #UseOkResult(runtime.run())
#expect(state_result == P4Lang.reject)
}
@Test func test_field_access2() async throws {
let simple_parser_declaration = """
parser main_parser() {
state start {
transition select (ts.count == 5) {
true: accept;
false: reject;
};
}
};
"""
var test_types = LexicalScopes().enter()
let fields = P4StructFields([
P4StructFieldIdentifier(name: "yesno", withType: P4Boolean()),
P4StructFieldIdentifier(name: "count", withType: P4Int()),
])
let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields)
test_types = test_types.declare(identifier: Identifier(name: "ts"), withValue: struct_type)
var test_values = ValueScopes().enter()
test_values = test_values.declare(
identifier: Identifier(name: "ts"),
withValue: P4StructValue(withType: struct_type, andInitializers: [
P4BooleanValue(withValue: true),
P4IntValue(withValue: 5),
]))
let program = try #UseOkResult(
Program.Compile(simple_parser_declaration, withGlobalTypes: test_types))
let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withInitialValues: test_values))
let (state_result, _) = try! #UseOkResult(runtime.run())
#expect(state_result == P4Lang.accept)
}
@Test func test_field_access2_opp() async throws {
let simple_parser_declaration = """
parser main_parser() {
state start {
transition select (ts.count == 5) {
true: accept;
false: reject;
};
}
};
"""
var test_types = LexicalScopes().enter()
let fields = P4StructFields([
P4StructFieldIdentifier(name: "yesno", withType: P4Boolean()),
P4StructFieldIdentifier(name: "count", withType: P4Int()),
])
let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields)
test_types = test_types.declare(identifier: Identifier(name: "ts"), withValue: struct_type)
var test_values = ValueScopes().enter()
test_values = test_values.declare(
identifier: Identifier(name: "ts"),
withValue: P4StructValue(withType: struct_type, andInitializers: [
P4BooleanValue(withValue: true),
P4IntValue(withValue: 8),
]))
let program = try #UseOkResult(
Program.Compile(simple_parser_declaration, withGlobalTypes: test_types))
let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withInitialValues: test_values))
let (state_result, _) = try! #UseOkResult(runtime.run())
#expect(state_result == P4Lang.reject)
}
@Test func test_field_access_nested() async throws {
let simple_parser_declaration = """
parser main_parser() {
state start {
int where_to = ts.ty.count;
transition select (where_to == 5) {
true: accept;
false: reject;
};
}
};
"""
var test_types = LexicalScopes().enter()
let ty_fields = P4StructFields([
P4StructFieldIdentifier(name: "yesno", withType: P4Boolean()),
P4StructFieldIdentifier(name: "count", withType: P4Int()),
])
let ty_struct_type = P4Struct(withName: Identifier(name: "nested"), andFields: ty_fields)
let ts_fields = P4StructFields([P4StructFieldIdentifier(name: "ty", withType: ty_struct_type)])
let ts_struct_type = P4Struct(withName: Identifier(name: "outer"), andFields: ts_fields)
test_types = test_types.declare(identifier: Identifier(name: "ts"), withValue: ts_struct_type)
var test_values = ValueScopes().enter()
test_values = test_values.declare(
identifier: Identifier(name: "ts"),
withValue: P4StructValue(
withType: ts_struct_type,
andInitializers: [
P4StructValue(
withType: ty_struct_type,
andInitializers: [
P4BooleanValue(withValue: true),
P4IntValue(withValue: 5),
])
]))
let program = try #UseOkResult(
Program.Compile(simple_parser_declaration, withGlobalTypes: test_types))
let runtime = try #UseOkResult(P4Runtime.ParserRuntime.create(program: program, withInitialValues: test_values))
let (state_result, _) = try! #UseOkResult(runtime.run())
#expect(state_result == P4Lang.accept)
}