implements PR016

This commit is contained in:
2026-03-24 13:42:21 +00:00
parent 8d8c3dc180
commit e4be2a033f
8 changed files with 437 additions and 69 deletions
@@ -902,7 +902,12 @@ public final class PbsParser {
}
private PbsAst.LValue parseLValue() {
final var root = consume(PbsTokenKind.IDENTIFIER, "Expected assignment target identifier");
final PbsToken root;
if (cursor.match(PbsTokenKind.IDENTIFIER, PbsTokenKind.THIS)) {
root = cursor.previous();
} else {
root = consume(PbsTokenKind.IDENTIFIER, "Expected assignment target identifier");
}
final var segments = new ArrayList<String>();
var end = root.end();
while (cursor.match(PbsTokenKind.DOT)) {
@@ -1057,7 +1062,7 @@ public final class PbsParser {
}
private boolean isAssignmentStatementStart() {
if (!cursor.check(PbsTokenKind.IDENTIFIER)) {
if (!cursor.check(PbsTokenKind.IDENTIFIER) && !cursor.check(PbsTokenKind.THIS)) {
return false;
}
@@ -12,6 +12,11 @@ final class PbsFlowBodyAnalyzer {
private final PbsFlowTypeOps typeOps = new PbsFlowTypeOps();
private final PbsFlowExpressionAnalyzer expressionAnalyzer = new PbsFlowExpressionAnalyzer(typeOps);
private record AssignmentTargetResolution(
TypeView type,
boolean assignable) {
}
public void validate(final PbsAst.File ast, final DiagnosticSink diagnostics) {
final var model = Model.from(ast);
@@ -136,7 +141,7 @@ final class PbsFlowBodyAnalyzer {
ExprUse.VALUE,
true,
this::analyzeBlock);
scope.bind(letStatement.name(), expected == null ? initializer.type() : expected);
scope.bind(letStatement.name(), expected == null ? initializer.type() : expected, !letStatement.isConst());
return;
}
if (statement instanceof PbsAst.ReturnStatement returnStatement) {
@@ -283,18 +288,233 @@ final class PbsFlowBodyAnalyzer {
return;
}
if (statement instanceof PbsAst.AssignStatement assignStatement) {
expressionAnalyzer.analyzeExpression(
assignStatement.value(),
scope,
null,
returnType,
resultErrorName,
receiverType,
model,
diagnostics,
ExprUse.VALUE,
true,
this::analyzeBlock);
analyzeAssignmentStatement(assignStatement, scope, returnType, resultErrorName, receiverType, model, diagnostics);
}
}
private void analyzeAssignmentStatement(
final PbsAst.AssignStatement assignStatement,
final Scope scope,
final TypeView returnType,
final String resultErrorName,
final TypeView receiverType,
final Model model,
final DiagnosticSink diagnostics) {
final var target = resolveAssignmentTarget(assignStatement.target(), scope, receiverType, model, diagnostics);
final var expectedType = target == null ? null : target.type();
final var valueType = expressionAnalyzer.analyzeExpression(
assignStatement.value(),
scope,
expectedType,
returnType,
resultErrorName,
receiverType,
model,
diagnostics,
ExprUse.VALUE,
true,
this::analyzeBlock).type();
if (target == null || !target.assignable()) {
return;
}
if (!assignmentCompatible(assignStatement.operator(), target.type(), valueType)) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_ASSIGN_TYPE_MISMATCH.name(),
"Assigned value type is not compatible with assignment target",
assignStatement.span());
}
}
private AssignmentTargetResolution resolveAssignmentTarget(
final PbsAst.LValue lValue,
final Scope scope,
final TypeView receiverType,
final Model model,
final DiagnosticSink diagnostics) {
final var rootName = lValue.rootName();
final var rootIsThis = "this".equals(rootName);
if (lValue.pathSegments().isEmpty()) {
if (rootIsThis) {
if (receiverType == null) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_INVALID_THIS_CONTEXT.name(),
"Invalid 'this' usage outside struct/service methods and constructors",
lValue.span());
}
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_ASSIGN_TARGET_NOT_ASSIGNABLE.name(),
"Assignment target is not assignable",
lValue.span());
return new AssignmentTargetResolution(TypeView.unknown(), false);
}
final var localType = scope.resolve(rootName);
if (localType != null) {
if (!scope.isMutable(rootName)) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_ASSIGN_TARGET_NOT_ASSIGNABLE.name(),
"Cannot assign to immutable local '%s'".formatted(rootName),
lValue.span());
return new AssignmentTargetResolution(localType, false);
}
return new AssignmentTargetResolution(localType, true);
}
if (isKnownNonAssignableRoot(rootName, model)) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_ASSIGN_TARGET_NOT_ASSIGNABLE.name(),
"Assignment target is not assignable",
lValue.span());
return new AssignmentTargetResolution(TypeView.unknown(), false);
}
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_ASSIGN_TARGET_UNRESOLVED.name(),
"Assignment target '%s' does not resolve".formatted(rootName),
lValue.span());
return new AssignmentTargetResolution(TypeView.unknown(), false);
}
TypeView currentType;
var currentReceiverIsThis = rootIsThis;
if (rootIsThis) {
if (receiverType == null) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_INVALID_THIS_CONTEXT.name(),
"Invalid 'this' usage outside struct/service methods and constructors",
lValue.span());
return new AssignmentTargetResolution(TypeView.unknown(), false);
}
currentType = receiverType;
} else {
final var localType = scope.resolve(rootName);
if (localType != null) {
currentType = localType;
} else if (model.serviceSingletons.containsKey(rootName)) {
currentType = model.serviceSingletons.get(rootName);
} else if (model.constTypes.containsKey(rootName)) {
currentType = model.constTypes.get(rootName);
} else {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_ASSIGN_TARGET_UNRESOLVED.name(),
"Assignment target '%s' does not resolve".formatted(rootName),
lValue.span());
return new AssignmentTargetResolution(TypeView.unknown(), false);
}
}
for (int i = 0; i < lValue.pathSegments().size(); i++) {
final var segment = lValue.pathSegments().get(i);
final var isLastSegment = i == lValue.pathSegments().size() - 1;
if (currentType.kind() != PbsFlowSemanticSupport.Kind.STRUCT) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_INVALID_MEMBER_ACCESS.name(),
"Assignment target segment '%s' is not a struct field".formatted(segment),
lValue.span());
return new AssignmentTargetResolution(TypeView.unknown(), false);
}
final var struct = model.structs.get(currentType.name());
if (struct == null) {
return new AssignmentTargetResolution(TypeView.unknown(), false);
}
final var field = struct.fields().get(segment);
if (field == null) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_INVALID_MEMBER_ACCESS.name(),
"Struct member '%s' does not exist".formatted(segment),
lValue.span());
return new AssignmentTargetResolution(TypeView.unknown(), false);
}
final var ownerContext = receiverType != null
&& receiverType.kind() == PbsFlowSemanticSupport.Kind.STRUCT
&& receiverType.name().equals(currentType.name());
if (isLastSegment) {
if (!canWriteStructField(field, ownerContext, currentReceiverIsThis)) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_FIELD_WRITE_ACCESS_DENIED.name(),
"Write access to struct field '%s' is not permitted".formatted(segment),
lValue.span());
return new AssignmentTargetResolution(field.type(), false);
}
return new AssignmentTargetResolution(field.type(), true);
}
if (!canReadStructField(field, ownerContext, currentReceiverIsThis)) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_FIELD_READ_ACCESS_DENIED.name(),
"Read access to struct field '%s' is not permitted".formatted(segment),
lValue.span());
return new AssignmentTargetResolution(field.type(), false);
}
currentType = field.type();
currentReceiverIsThis = false;
}
return new AssignmentTargetResolution(TypeView.unknown(), false);
}
private boolean assignmentCompatible(
final PbsAst.AssignOperator operator,
final TypeView targetType,
final TypeView valueType) {
if (operator == PbsAst.AssignOperator.ASSIGN) {
return typeOps.compatible(valueType, targetType);
}
final String binaryOperator = switch (operator) {
case ADD_ASSIGN -> "+";
case SUB_ASSIGN -> "-";
case MUL_ASSIGN -> "*";
case DIV_ASSIGN -> "/";
case MOD_ASSIGN -> "%";
case ASSIGN -> "=";
};
if ("=".equals(binaryOperator)) {
return typeOps.compatible(valueType, targetType);
}
final var resultType = typeOps.inferBinaryResult(binaryOperator, targetType, valueType);
return typeOps.compatible(resultType, targetType);
}
private boolean canReadStructField(
final PbsFlowSemanticSupport.StructFieldInfo field,
final boolean ownerContext,
final boolean receiverIsThis) {
if (field.isPublic()) {
return true;
}
return ownerContext && receiverIsThis;
}
private boolean canWriteStructField(
final PbsFlowSemanticSupport.StructFieldInfo field,
final boolean ownerContext,
final boolean receiverIsThis) {
if (!field.isPublic()) {
return ownerContext && receiverIsThis;
}
if (ownerContext) {
return true;
}
return field.isMutable();
}
private boolean isKnownNonAssignableRoot(
final String rootName,
final Model model) {
return model.serviceSingletons.containsKey(rootName)
|| model.constTypes.containsKey(rootName)
|| model.topLevelCallables.containsKey(rootName)
|| model.callbacks.containsKey(rootName)
|| model.enums.containsKey(rootName)
|| model.errors.containsKey(rootName)
|| model.structs.containsKey(rootName)
|| model.services.containsKey(rootName)
|| model.contracts.containsKey(rootName);
}
}
@@ -750,9 +750,16 @@ final class PbsFlowExpressionAnalyzer {
if (struct == null) {
return ExprResult.type(TypeView.unknown());
}
final var fieldType = struct.fields().get(memberExpr.memberName());
if (fieldType != null) {
return ExprResult.type(fieldType);
final var field = struct.fields().get(memberExpr.memberName());
if (field != null) {
if (!canReadStructField(field, receiver, memberExpr.receiver(), receiverType)) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_FIELD_READ_ACCESS_DENIED.name(),
"Read access to struct field '%s' is not permitted".formatted(memberExpr.memberName()),
memberExpr.span());
return ExprResult.type(TypeView.unknown());
}
return ExprResult.type(field.type());
}
final var methods = struct.methods().get(memberExpr.memberName());
if (methods != null && !methods.isEmpty()) {
@@ -825,6 +832,21 @@ final class PbsFlowExpressionAnalyzer {
return ExprResult.type(TypeView.unknown());
}
private boolean canReadStructField(
final PbsFlowSemanticSupport.StructFieldInfo field,
final TypeView receiver,
final PbsAst.Expression receiverExpr,
final TypeView currentReceiverType) {
if (field.isPublic()) {
return true;
}
return receiverExpr instanceof PbsAst.ThisExpr
&& currentReceiverType != null
&& currentReceiverType.kind() == Kind.STRUCT
&& receiver.kind() == Kind.STRUCT
&& receiver.name().equals(currentReceiverType.name());
}
private TypeView analyzeSwitchExpression(
final PbsAst.SwitchExpr switchExpr,
final Scope scope,
@@ -141,9 +141,15 @@ final class PbsFlowSemanticSupport {
}
record StructInfo(
Map<String, TypeView> fields,
Map<String, StructFieldInfo> fields,
Map<String, List<CallableSymbol>> methods) {
}
record StructFieldInfo(
TypeView type,
boolean isPublic,
boolean isMutable) {
}
record ServiceInfo(
Map<String, List<CallableSymbol>> methods) {
@@ -168,9 +174,14 @@ final class PbsFlowSemanticSupport {
final var model = new Model();
for (final var topDecl : ast.topDecls()) {
if (topDecl instanceof PbsAst.StructDecl structDecl) {
final var fields = new HashMap<String, TypeView>();
final var fields = new HashMap<String, StructFieldInfo>();
for (final var field : structDecl.fields()) {
fields.put(field.name(), model.typeFrom(field.typeRef()));
fields.put(
field.name(),
new StructFieldInfo(
model.typeFrom(field.typeRef()),
field.isPublic(),
field.isMutable()));
}
final var methods = new HashMap<String, List<CallableSymbol>>();
for (final var method : structDecl.methods()) {
@@ -348,7 +359,12 @@ final class PbsFlowSemanticSupport {
}
static final class Scope {
private final Map<String, TypeView> names = new HashMap<>();
private final Map<String, LocalSymbol> names = new HashMap<>();
record LocalSymbol(
TypeView type,
boolean mutable) {
}
Scope copy() {
final var scope = new Scope();
@@ -357,11 +373,21 @@ final class PbsFlowSemanticSupport {
}
void bind(final String name, final TypeView type) {
names.put(name, type);
bind(name, type, true);
}
void bind(final String name, final TypeView type, final boolean mutable) {
names.put(name, new LocalSymbol(type, mutable));
}
TypeView resolve(final String name) {
return names.get(name);
final var symbol = names.get(name);
return symbol == null ? null : symbol.type();
}
boolean isMutable(final String name) {
final var symbol = names.get(name);
return symbol != null && symbol.mutable();
}
}
}
@@ -20,6 +20,11 @@ public enum PbsSemanticsErrors {
E_SEM_INVALID_MEMBER_ACCESS,
E_SEM_INVALID_THIS_CONTEXT,
E_SEM_INVALID_SELF_CONTEXT,
E_SEM_ASSIGN_TARGET_UNRESOLVED,
E_SEM_ASSIGN_TARGET_NOT_ASSIGNABLE,
E_SEM_ASSIGN_TYPE_MISMATCH,
E_SEM_FIELD_READ_ACCESS_DENIED,
E_SEM_FIELD_WRITE_ACCESS_DENIED,
E_SEM_IF_NON_BOOL_CONDITION,
E_SEM_IF_BRANCH_TYPE_MISMATCH,
E_SEM_SWITCH_SELECTOR_INVALID,