Merged pull request #18 from 'feature/free'.

BenediktMagnus · web-flow · commit e2e6b29e27e0 · 2026-01-20T16:44:28.000+01:00
Free statement
diff --git a/examples/memoryManagement/main.ph b/examples/memoryManagement/main.ph
@@ -0,0 +1,17 @@
+module MemoryManagementExample;
+
+import Standard.Io;
+
+function main ()
+{
+    let myArray := new Array[String](3);
+    myArray.set(1, 'Initialisation succeeded.');
+
+    Io.writeLine(myArray.get(1));
+
+    free myArray;
+
+    Io.writeLine('Segmentation fault should follow...');
+
+    Io.writeLine(myArray.get(1));
+}
diff --git a/src/connector/connector.ts b/src/connector/connector.ts
@@ -789,6 +789,8 @@ export class Connector
                 return this.connectAssignment(statement, context);
             case SyntaxKind.CallExpression:
                 return this.connectCallExpression(statement, context);
+            case SyntaxKind.FreeStatement:
+                return this.connectFreeStatement(statement, context);
             case SyntaxKind.Section:
                 return this.connectSection(statement, context);
             case SyntaxKind.LocalVariableDeclaration:
@@ -967,6 +969,24 @@ export class Connector
         return new SemanticNodes.WhileStatement(condition, section);
     }
 
+    private connectFreeStatement (freeStatement: SyntaxNodes.FreeStatement, context: FunctionContext): SemanticNodes.FreeStatement
+    {
+        const expression = this.connectExpression(freeStatement.expression, context);
+
+        if (BuildInTypes.isBuildInType(expression.type) && !BuildInTypes.isArray(expression.type))
+        {
+            this.diagnostic.throw(
+                new Diagnostic.Error(
+                    `Cannot free the non-reference type "${expression.type.namespace.baseName}".`,
+                    Diagnostic.Codes.FreeNonReferenceTypeError,
+                    freeStatement.expression.token
+                )
+            );
+        }
+
+        return new SemanticNodes.FreeStatement(expression);
+    }
+
     private connectAssignment (assignment: SyntaxNodes.Assignment, context: FunctionContext): SemanticNodes.Assignment
     {
         const namespace = Namespace.constructFromNamespace(context.module.namespace, assignment.identifier.content);
diff --git a/src/connector/genericNodes/freeStatementGenericNode.ts b/src/connector/genericNodes/freeStatementGenericNode.ts
@@ -0,0 +1,15 @@
+import { SemanticKind } from '../semanticKind';
+
+export class FreeStatementGenericNode <Expression>
+{
+    public readonly kind: SemanticKind.FreeStatement;
+
+    public readonly expression: Expression;
+
+    constructor (expression: Expression)
+    {
+        this.kind = SemanticKind.FreeStatement;
+
+        this.expression = expression;
+    }
+}
diff --git a/src/connector/genericNodes/index.ts b/src/connector/genericNodes/index.ts
@@ -11,6 +11,7 @@ export { ElseClauseGenericNode as ElseClause } from './elseClauseGenericNode';
 export { FieldDeclarationGenericNode as FieldDeclaration } from './fieldDeclarationGenericNode';
 export { FieldExpressionGenericNode as FieldExpression } from './fieldExpressionGenericNode';
 export { FileGenericNode as File } from './fileGenericNode';
+export { FreeStatementGenericNode as FreeStatement } from './freeStatementGenericNode';
 export { FunctionDeclarationGenericNode as FunctionDeclaration } from './functionDeclarationGenericNode';
 export { GlobalVariableDeclarationGenericNode as GlobalVariableDeclaration } from './globalVariableDeclarationGenericNode';
 export { IfStatementGenericNode as IfStatement } from './ifStatementGenericNode';
@@ -34,6 +35,7 @@ import { ElseClauseGenericNode } from './elseClauseGenericNode';
 import { FieldDeclarationGenericNode } from './fieldDeclarationGenericNode';
 import { FieldExpressionGenericNode } from './fieldExpressionGenericNode';
 import { FileGenericNode } from './fileGenericNode';
+import { FreeStatementGenericNode } from './freeStatementGenericNode';
 import { FunctionDeclarationGenericNode } from './functionDeclarationGenericNode';
 import { GlobalVariableDeclarationGenericNode } from './globalVariableDeclarationGenericNode';
 import { IfStatementGenericNode } from './ifStatementGenericNode';
@@ -71,6 +73,7 @@ export type GenericNode<
     | FieldDeclarationGenericNode<Expression, TypeLikeSymbol>
     | FieldExpressionGenericNode<Expression, TypeLikeSymbol>
     | FileGenericNode<GlobalVariableDeclaration, FieldDeclaration, FunctionDeclaration, ClassTypeSymbol, TypeLikeSymbol>
+    | FreeStatementGenericNode<Expression>
     | FunctionDeclarationGenericNode<Section, TypeLikeSymbol>
     | GlobalVariableDeclarationGenericNode<Expression, TypeLikeSymbol>
     | IfStatementGenericNode<Expression, Section, ElseClause>
@@ -87,6 +90,7 @@ export type GenericStatement<Expression, Statement, Section, ElseClause, Variabl
     ArraySetExpressionGenericNode<Expression, TypeLikeSymbol>
     | AssignmentGenericNode<Expression, FieldExpression, VariableExpression>
     | CallExpressionGenericNode<Expression, TypeLikeSymbol>
+    | FreeStatementGenericNode<Expression>
     | IfStatementGenericNode<Expression, Section, ElseClause>
     | LocalVariableDeclarationGenericNode<Expression, TypeLikeSymbol>
     | ReturnStatementGenericNode<Expression>
diff --git a/src/connector/semanticKind.ts b/src/connector/semanticKind.ts
@@ -16,6 +16,7 @@ export enum SemanticKind
     LocalVariableDeclaration = 'LocalVariableDeclaration',
     GlobalVariableDeclaration = 'GlobalVariableDeclaration',
     FieldDeclaration = 'FieldDeclaration',
+    FreeStatement = 'FreeStatement',
     // Expressions
     LiteralExpression = 'LiteralExpression',
     InstantiationExpression = 'InstantiationExpression',
diff --git a/src/connector/semanticNodes/index.ts b/src/connector/semanticNodes/index.ts
@@ -17,6 +17,7 @@ export class File extends GenericNodes.File<
     SemanticSymbols.GenericType,
     SemanticSymbols.TypeLike
 > {}
+export class FreeStatement extends GenericNodes.FreeStatement<Expression> {}
 export class FunctionDeclaration extends GenericNodes.FunctionDeclaration<Section, SemanticSymbols.TypeLike> {}
 export class GlobalVariableDeclaration extends GenericNodes.GlobalVariableDeclaration<Expression, SemanticSymbols.TypeLike> {}
 export class IfStatement extends GenericNodes.IfStatement<Expression, Section, ElseClause> {}
@@ -37,6 +38,7 @@ export type SemanticNode =
     | ElseClause
     | FieldExpression
     | File
+    | FreeStatement
     | FunctionDeclaration
     | GlobalVariableDeclaration
     | FieldDeclaration
@@ -55,6 +57,7 @@ export type Statement =
     ArraySetExpression
     | Assignment
     | CallExpression
+    | FreeStatement
     | IfStatement
     | LocalVariableDeclaration
     | ReturnStatement
diff --git a/src/definitions/buildInFunctions.ts b/src/definitions/buildInFunctions.ts
@@ -42,4 +42,17 @@ export abstract class BuildInFunctions
         null,
         true
     );
+
+    public static readonly free = new SpecialisedSymbols.Function(
+        Namespace.constructFromStrings('Standard', 'Memory', 'free'),
+        BuildInTypes.noType,
+        [
+            new SpecialisedSymbols.FunctionParameter(
+                Namespace.constructFromStrings('Standard', 'Memory', 'free', 'pointer'),
+                BuildInTypes.pointer
+            )
+        ],
+        null,
+        true
+    );
 }
diff --git a/src/definitions/buildInModules.ts b/src/definitions/buildInModules.ts
@@ -24,7 +24,8 @@ export abstract class BuildInModules
         new Map(),
         new Map(
             [
-                [BuildInFunctions.allocate.namespace.qualifiedName, BuildInFunctions.allocate]
+                [BuildInFunctions.allocate.namespace.qualifiedName, BuildInFunctions.allocate],
+                [BuildInFunctions.free.namespace.qualifiedName, BuildInFunctions.free]
             ]
         ),
         false
diff --git a/src/diagnostic/diagnosticCodes.ts b/src/diagnostic/diagnosticCodes.ts
@@ -76,6 +76,7 @@ export enum DiagnosticCodes // TODO: Should this be singular?
     UnexpectedTokenInGenericsDeclarationError = 'E1077',
     NonGenericTypeIsUsedAsGenericTypeError = 'E1078',
     UnknownArrayAccessError = 'E1079',
+    FreeNonReferenceTypeError = 'E1080',
     // Warnings:
     ExperimentalPlatformWarning = 'W1001',
     // Infos:
diff --git a/src/lexer/lexer.ts b/src/lexer/lexer.ts
@@ -411,6 +411,9 @@ export class Lexer
             case 'new':
                 kind = TokenKind.NewKeyword;
                 break;
+            case 'free':
+                kind = TokenKind.FreeKeyword;
+                break;
             case 'variable':
                 kind = TokenKind.VariableKeyword;
                 break;
diff --git a/src/lexer/tokenKind.ts b/src/lexer/tokenKind.ts
@@ -46,6 +46,7 @@ export enum TokenKind
     FalseKeyword,
     ImportKeyword,
     NewKeyword,
+    FreeKeyword,
     VariableKeyword,
     ConstantKeyword,
     FieldKeyword,
diff --git a/src/parser/parser.ts b/src/parser/parser.ts
@@ -646,6 +646,9 @@ export class Parser
             case TokenKind.WhileKeyword:
                 result = this.parseWhileStatement();
                 break;
+            case TokenKind.FreeKeyword:
+                result = this.parseFreeStatement();
+                break;
             case TokenKind.IdentifierToken:
             {
                 if (this.getFollowerToken().kind == TokenKind.AssignmentOperator)
@@ -846,6 +849,14 @@ export class Parser
         return new SyntaxNodes.WhileStatement(keyword, condition, section);
     }
 
+    private parseFreeStatement (): SyntaxNodes.FreeStatement
+    {
+        const keyword = this.consumeNextToken();
+        const expression = this.parseExpression();
+
+        return new SyntaxNodes.FreeStatement(keyword, expression);
+    }
+
     private parseAssignment (): SyntaxNodes.Assignment
     {
         const identifierToken = this.consumeNextToken();
diff --git a/src/parser/syntaxKind.ts b/src/parser/syntaxKind.ts
@@ -20,6 +20,7 @@ export enum SyntaxKind
     ReturnStatement = 'ReturnStatement',
     IfStatement = 'IfStatement',
     WhileStatement = 'WhileStatement',
+    FreeStatement = 'FreeStatement',
     // Expressions
     AccessExpression = 'AccessExpression',
     UnaryExpression = 'UnaryExpression',
diff --git a/src/parser/syntaxNodes/freeStatementSyntaxNode.ts b/src/parser/syntaxNodes/freeStatementSyntaxNode.ts
@@ -0,0 +1,24 @@
+import * as SyntaxNodes from '.';
+import { SyntaxKind } from '../syntaxKind';
+import { Token } from '../../lexer/token';
+
+export class FreeStatementSyntaxNode
+{
+    public readonly kind: SyntaxKind.FreeStatement;
+    public readonly token: Token;
+    public readonly children: Iterable<SyntaxNodes.SyntaxNode>;
+
+    public readonly keyword: Token;
+    public readonly expression: SyntaxNodes.Expression;
+
+    constructor (keyword: Token, expression: SyntaxNodes.Expression)
+    {
+        this.kind = SyntaxKind.FreeStatement;
+
+        this.keyword = keyword;
+        this.expression = expression;
+
+        this.token = this.keyword;
+        this.children = [];
+    }
+}
diff --git a/src/parser/syntaxNodes/index.ts b/src/parser/syntaxNodes/index.ts
@@ -6,6 +6,7 @@ export { CallExpressionSyntaxNode as CallExpression } from './callExpressionSynt
 export { ElseClauseSyntaxNode as ElseClause } from './elseClauseSyntaxNode';
 export { FieldVariableDeclarationSyntaxNode as FieldVariableDeclaration } from './fieldVariableDeclarationSyntaxNode';
 export { FileSyntaxNode as File } from './fileSyntaxNode';
+export { FreeStatementSyntaxNode as FreeStatement } from './freeStatementSyntaxNode';
 export { FunctionDeclarationSyntaxNode as FunctionDeclaration } from './functionDeclarationSyntaxNode';
 export { FunctionParameterSyntaxNode as FunctionParameter } from './functionParameterSyntaxNode';
 export { GenericParameterSyntaxNode as GenericParameter } from './genericParameterSyntaxNode';
@@ -32,6 +33,7 @@ import { BracketedExpressionSyntaxNode } from './bracketedExpressionSyntaxNode';
 import { CallExpressionSyntaxNode } from './callExpressionSyntaxNode';
 import { ElseClauseSyntaxNode } from './elseClauseSyntaxNode';
 import { FileSyntaxNode } from './fileSyntaxNode';
+import { FreeStatementSyntaxNode } from './freeStatementSyntaxNode';
 import { FunctionDeclarationSyntaxNode } from './functionDeclarationSyntaxNode';
 import { FunctionParameterSyntaxNode } from './functionParameterSyntaxNode';
 import { GenericParameterSyntaxNode } from './genericParameterSyntaxNode';
@@ -59,6 +61,7 @@ export type SyntaxNode =
     | CallExpressionSyntaxNode
     | ElseClauseSyntaxNode
     | FileSyntaxNode
+    | FreeStatementSyntaxNode
     | FunctionDeclarationSyntaxNode
     | FunctionParameterSyntaxNode
     | GenericParameterSyntaxNode
@@ -82,6 +85,7 @@ export type Statement =
     AccessExpressionSyntaxNode
     | AssignmentSyntaxNode
     | CallExpressionSyntaxNode
+    | FreeStatementSyntaxNode
     | IfStatementSyntaxNode
     | LocalVariableDeclarationSyntaxNode
     | ReturnStatementSyntaxNode
diff --git a/src/semanticLowerer/semanticLowerer.ts b/src/semanticLowerer/semanticLowerer.ts
@@ -392,7 +392,8 @@ export default class SemanticLowerer
                 return [this.lowerSection(statement)];
             case SemanticKind.WhileStatement:
                 return this.lowerWhileStatement(statement);
-
+            case SemanticKind.FreeStatement:
+                return [this.lowerFreeStatement(statement)];
         }
     }
 
@@ -526,6 +527,28 @@ export default class SemanticLowerer
         ];
     }
 
+    private lowerFreeStatement (freeStatement: SpecialisedNodes.FreeStatement): LoweredNodes.CallExpression
+    {
+        /* Freeing of an object
+         * Lowers a free statement by reference to a function call that frees the object.
+
+            free object;
+
+            -->
+
+            free(object)
+        */
+
+        this.importBuildInModuleIfNeeded(BuildInModules.memory);
+
+        const objectExpression = this.lowerExpression(freeStatement.expression);
+
+        const freeFunctionSymbol = BuildInFunctions.free;
+        const callExpression = new LoweredNodes.CallExpression(freeFunctionSymbol, [objectExpression], null, freeFunctionSymbol.returnType);
+
+        return callExpression;
+    }
+
     private lowerAssignment (assignment: SpecialisedNodes.Assignment): LoweredNodes.Assignment
     {
         const loweredFromExpression = this.lowerExpression(assignment.from);
diff --git a/src/specialiser/specialisedNodes/index.ts b/src/specialiser/specialisedNodes/index.ts
@@ -17,6 +17,7 @@ export class File extends GenericNodes.File<
     SpecialisedSymbols.ConcreteType,
     SpecialisedSymbols.ConcreteType
 > {}
+export class FreeStatement extends GenericNodes.FreeStatement<Expression> {}
 export class FunctionDeclaration extends GenericNodes.FunctionDeclaration<Section, SpecialisedSymbols.ConcreteType> {}
 export class GlobalVariableDeclaration extends GenericNodes.GlobalVariableDeclaration<Expression, SpecialisedSymbols.ConcreteType> {}
 export class IfStatement extends GenericNodes.IfStatement<Expression, Section, ElseClause> {}
@@ -40,6 +41,7 @@ export type SpecialisedNode = // TODO: Rename to "Node"?
     | ElseClause
     | FieldExpression
     | File
+    | FreeStatement
     | FunctionDeclaration
     | GlobalVariableDeclaration
     | FieldDeclaration
@@ -58,6 +60,7 @@ export type Statement =
     ArraySetExpression
     | Assignment
     | CallExpression
+    | FreeStatement
     | IfStatement
     | LocalVariableDeclaration
     | ReturnStatement
diff --git a/src/specialiser/specialiser.ts b/src/specialiser/specialiser.ts
@@ -781,6 +781,8 @@ export class Specialiser
                 return this.specialiseArraySetExpression(statement);
             case SemanticKind.WhileStatement:
                 return this.specialiseWhileStatement(statement);
+            case SemanticKind.FreeStatement:
+                return this.specialiseFreeStatement(statement);
         }
     }
 
@@ -839,6 +841,13 @@ export class Specialiser
         return new SpecialisedNodes.WhileStatement(specialisedCondition, specialisedSection);
     }
 
+    private specialiseFreeStatement (freeStatement: SemanticNodes.FreeStatement): SpecialisedNodes.FreeStatement
+    {
+        const specialisedExpression = this.specialiseExpression(freeStatement.expression);
+
+        return new SpecialisedNodes.FreeStatement(specialisedExpression);
+    }
+
     private specialiseLocalVariableDeclaration (
         variableDeclaration: SemanticNodes.LocalVariableDeclaration
     ): SpecialisedNodes.LocalVariableDeclaration
diff --git a/tests/compiler/lexer.ts b/tests/compiler/lexer.ts
@@ -107,6 +107,7 @@ describe('Lexer',
             new InputToTokenKind('true', TokenKind.TrueKeyword, 'the true keyword'),
             new InputToTokenKind('false', TokenKind.FalseKeyword, 'the false keyword'),
             new InputToTokenKind('new', TokenKind.NewKeyword, 'the new keyword'),
+            new InputToTokenKind('free', TokenKind.FreeKeyword, 'the free keyword'),
             new InputToTokenKind('module', TokenKind.ModuleKeyword, 'the module keyword'),
             new InputToTokenKind('class', TokenKind.ClassKeyword, 'the class keyword'),
             new InputToTokenKind('import', TokenKind.ImportKeyword, 'the import keyword'),

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,8 @@ export abstract class BuildInModules`
`24`	`24`	`new Map(),`
`25`	`25`	`new Map(`
`26`	`26`	`[`
`27`		`- [BuildInFunctions.allocate.namespace.qualifiedName, BuildInFunctions.allocate]`
	`27`	`+ [BuildInFunctions.allocate.namespace.qualifiedName, BuildInFunctions.allocate],`
	`28`	`+ [BuildInFunctions.free.namespace.qualifiedName, BuildInFunctions.free]`
`28`	`29`	`]`
`29`	`30`	`),`
`30`	`31`	`false`