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/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)
}