Hotfix/jcli upgrade fix (#24)
* 🐞️ isSameType: Add a base case (#8)
* Core
- Added a TODO where we are meant to insert the fallback check in `isSameType(Type t1, Type t2)`
* TypeChecker
- Added backported `isSameType(Type 1, Type t2)` fix for #114
* 🐞️ Functions: Return position enforcement (#6)
* Parser
- Added a TODO in `wantsBody == true` case in `parseFuncDef()` to check for the return keyword's position
* Parser
- Added a check in `parseFuncDef()` which, is a `ReturnStmt` is found, then crash the parser if it is found anywhere besides the last statement
* Test cases
- Added test cases to test the `return` statement position enforcement
* 🧠 Feature: Direct function calls (#11)
* Test cases
- Added `simple_direct_func_call.t` to test direct function calls
* Test cases
- Removed tabs which broke lexing
* AST nodes
- `FunctionCall` now has the ability to be marked as statement-level by calling `makeStatementLevel()`, this can then be queried later via `isStatementLevelFuncCall()`
* Parser
- Statement-level function calls were never actually returned, resulting in `null` being returned by `parseName()` - this has now been fixed.
- Along with this we now "mark" this `FunctionCall` AST node as statement-level when it occurs in `parseName()`
* Instruction
- Allow `FuncCallInstr` to be makred as statement-level and queired much in the same manner as its corresponding AST-node/parser-node `FunctionCall`
* Dependency
- Added support for `DNode` generation in `generalPass()` for `FunctionCall` AST nodes
* TypeChecker
- Handle `FunctionCall`s differently in terms of code generation dependent on whether or not rhe call is within an expression of statement-level
* DGen
- Handle statement-level function calls (`FuncCallInstr`s) differently by tacking on an additional `";"` to the emit string
* - Added `simple_direct_func_call.t` to GitHub pipeline
* DGen
- Added instrumentation for semantic code generation for `simple_function_recursion_factorial.t`
- Added TODO for future `simple_func_call_direct.t`
Test cases
- Added `simple_function_recursion_factorial.t` to test recursion
Pipelines
- Added `simple_function_recursion_factorial.t` to `emit` stage
* DGen
- Made `if` an `else if` - this wouldn't of affected anything but just to be correct
* DGen
- Added semantic code generation instrumentation for test case `simple_direct_func_call.t`
Test cases
- Updated test case `simple_direct_func_call.t`
* 🧠 Feature: Meta-programming engine (#10)
* Parser
- Added new interface `Cloneable`
* Symbols
- Added new `Statement`-based type: `Macro` to support `Macro`(s)
* MetaProcessor
- Added the `MetaProcessor`
TypeChecker
- Added the `MetaProcessor` instance to the `TypeChecker`, it will be instantiated upon the `TypeChecker`'s construction and later have its `.process()` method called as the first call in `beginCheck()`
* TypedEntity
- Added a `setType(string)` method to update the internal `type` field
* MetaProcessor
- Added a type-re-writing facility via `typeRewrite(TypedEntity)` which will re-write the types such as `size_t`, `ssize_t` and so forth
Test cases
- Added a test case `meta/types.t` which tests this
* MetaProcessor
- Updated the constructor to only take in an instance of the `TypeChecker`
- Updated the `process()` method to take in a `Container` such that it can be used recursively
- Commented code
- Added a recursive call to `process(Container)` when `curStmt` is a kind-of `Container` (this ensures that we reach the `VariableParameter`s of `Function` (die to them making up the `Statement[]` of `Function` type)
- Removed unused `cmp` import `std.string`
- Added type-rewrite for `ssize_t` -> `long`
TypeChecker
- Updated the constructor call to `MetaProcessor` to use its new API
- Updated call to `process()` to now be `process(modulle)`
Test cases
- Updated `types.t` to test re-writing of the `Function`'s parameters
* MetaProcessor
- Added another FIXME
* Mcro
- Added interface `MTypeRewritable` to represent any AST node which has a `setType(string)` and `string getType()` method for rewriting- Added `Sizeof` which is a kind-of `IntegerLiteral`
Data
- Made `TypedEntity` implement the `MTypeRewritable` interface
Expressions
- Made `IntegerLiteral` non-final such that we can inherit from it
- Added a final `setNumber(string)` method to `NumberLiteral` to update the literal
MetaProcessor
- The type rewriting mechanism now operates on `MTypeRewritable` AST nodes
- Work has begun on `sizeOf_Literalize(Sizeof)` which is to determine the `Type` of the `Sizeof` statement and then calculate the memory width and update its literal (as it is a kind-of `NunberLiteral`) to said size
Test cases
- Added `meta/sizeof.t` to test `sizeof` functionality
* Mcro
- Added interface type `MStatementSearchable`
* Mcro
- Redefined `MStatementSearchable`
- Added `MStatementReplaceable`
- Added `Repr` (a kind-of `Expression`) which will be used as an example to test out the aforementioned two interfaces
* MStatementSearchable
- Added method `search(TypeInfo_Class clazzType)` which uses a `TypeInfo_Class` to search for all types matching that (and which are sub-types of `Statement` and then adds these to a list and returns it in the form of `Statement[]`
* MStatementReplaceable
- Implemented `replace(Statement thiz, Statement that)` which replaces the `Statement` in the first argument with that of the `Statement` in the second argument
* MStatementSearchable
- Added documentation for `search(TypeInfo_Class)` method
* Mcro
- Made `Repr` implement `MStatementSearchable`
- Added new interface `MCloneable` to represent PNode's which are deeply-cloneable
* Data
- Made `DiscardStatement` searchabe via implementing `MStatementSearchable`
- Added a stub override for implementing `MStatementReplaceable` in `DiscardStatement`
* Mcro
- Updated `MStatementReplaceable` to have its `replace(Statement, Statement)` method return a boolean `true` if the replacement was successful, else `false`
* Parsing
- Added the ability to parse a `Repr` statement
Check
- Added `GENERIC_TYPE_DECLARE` and `REPR` as new `SymbolType`(s)
Data
- `DiscardStatement` now implements the `bool replace(Statement, Statement)` method
MetaProcessor
- Added the ability to replace statements that occur within any _other_ statements which implement `MStatementSearchable` and `MStatementReplaceable`
Test cases
- Added `meta/simple_meta_replace.t` to test all of this
Diagrams
- Added diagram on how the meta system works
* MetaProcessor
- Removed unused `replace` method
* MetaProcessor
- Accept a new argument to the `MetaProcessor(TypeChecker)` constructor indicating whether or not the `MetaProcessor` is enabled or not
TypeChecker
- Enable the `MetaProcessor`
* Mcro
- Removed `Sizeof`, we will let it be parsed as a normal `FunctionCall` and then inspect in `MetaProcessor`
* MetaProcessor
- Disabled `sizeOf_Literalize` for now
- Search for all `FunctionCall` statements in `process(Container)`
* MetaProcessor
- Removed old code for testing `MStatementSearchable` and `MStatementReplaceable`
- Added note that we will have to investigate a recursive `MTypeRewritable` to be able to support things like `sizeof(size_t)`
- Implemented module-level `sizeof(<ident_type>)` support
- Added `Number`-kind of types support to `sizeOf_Literalize`(string)`
Containers (`Module`)
- Added `MStatementSearchable` and `MStatementReplaceable` support to `Module` container type
Data
- Added `MStatementSearchable` and `MStatementReplaceable` support to `Variable`
- Added `MStatementSearchable` and `MStatementReplaceable` support to `VariableAssignment`
- Work-in-progress for adding `MStatementSearchable` and `MStatementReplaceable` support to `FunctionCall`
- Added a note to return `false` in `DiscardStatement` if the statement to be replaced is us (the `DiscardSTatement`) ourselves
Test cases
- Updated the `meta/sizeof.t` test case
* Containers
- Inherit from `MStatementSearchable` and `MStatementReplaceable`
- Removed direct interface inheritance of `MStatementSearchable, MStatementReplaceable` and `MStatementReplaceable`, rely on `Container` now
* Struct
- Implemented the `search` method for `MStatementSearchable`
- Implemented the `replace` method for `MStatementReplaceable`
Clazz
- Implemented the `search` method for `MStatementSearchable`
- Implemented the `replace` method for `MStatementReplaceable`
BinaryOperatorExpression
- Implemented the `search` method for `MStatementSearchable`
- Implemented the `replace` method for `MStatementReplaceable`
Function
- Implemented the `search` method for `MStatementSearchable`
- Implemented the `replace` method for `MStatementReplaceable`
Variable
- Fixed the `replace` method implementation which had a bug that would never replace the node `VariableAssignment` inside of it
VariableAssignmentStdAlone
- Implemented the `search` method for `MStatementSearchable`
- Implemented the `replace` method for `MStatementReplaceable`
IfStatement
- Implemented the `search` method for `MStatementSearchable`
- Implemented the `replace` method for `MStatementReplaceable`
WhileLoop
- Implemented the `search` method for `MStatementSearchable`
- Implemented the `replace` method for `MStatementReplaceable`
ForLoop
- Implemented the `search` method for `MStatementSearchable`
- Implemented the `replace` method for `MStatementReplaceable`
Branch
- Implemented the `search` method for `MStatementSearchable`
- Implemented the `replace` method for `MStatementReplaceable`
* MetaProcessor
- Added a future TODO for occurence of certain types that are alises (i.e. `size_t` appearing in a expression context like `sizeof(size_t)`
- Now that all `Container`-based types are `MStatementReplaceable` we no longer need this check
* MetaProcessor
- Removed `break` which caused only one `sizeof()` function call to be replaced, we should have been looping over each `FunctionCall` found with `search` and then replacing ech that had a name of `sizeof` with a `NumberLiteral` expression
- Moved all type alias replacement code into a new method; `doTypeAlias(Container, Statement)`
- Added some rudiementary support for replacing any `IdentExpression` containing `size_t` with `uint`
IdentExpression
- Made it `MStatementSearchable` and `MStatementReplaceable`
Test cases
- Updated test case `meta/sizeof.t` to test the `sizeof(<expr>)` AST node in the `MetaProcessor`
Documentation
- Added diagram showing the `MStatementSearchable` and `MStatementReplaceable` in action
* Compiler
- If the T compiler was built on `X86` then set the maximum width to 4 bytes
- If the T compiler was built on `X86_64` then set the maximum width to 8 bytes
- Pass in the `Compiler` instance to the `TypeChecker` in `doTypeCheck()`
TypeChecker
- Added `Compiler` field and now accept it in constructor
- If just single parameter constructor then pass in `null` as the `Compiler` instance
- Added `getCompiler()` to get the instance
MetaProcessor
- Extract the `CompilerConfiguration` via the `TypeChecker`'s `getCompiler()`
- Implemented `getSystemType(string)` which will map `size_t`/`ssize_t` to the correct maximum width'd type your system supports via the `types:max_width` config entry
* CompilerConfiguration
- Added `defaultConfig()`
* Compiler
- Removed `defaultConfig()`
- During construction call `CompilerConfiguration.defaultConfig()` in order to generate the default config
- Pass the config into `TypeChecker` in `doTypeCheck()`
* TypeChecker
- No longer store a field for the `Compiler` but rather store a field for the `CompilerConfiguration`
- Removed single parameter constructor for `TypeChecker`
- Constructor now uses the default `CompilerConfiguration` if not specified; therefore fixing the issue with unit tests failing
MetaProcessor
- Extract the compiler configuration via `tc.getConfig()`
- Updated `typeRewrite(MTypeRewritable)` to use `getSystemType(string)` to lookup concrete types for `size_t`/`ssize_t`
- `doTypeAlias(Container, Statement)` now uses `getSsstemType(string)` to lookup the concrete types for alises such as `size_t`/`ssize_t`
* MetaProcessor
- Implemented `isSystemType(string)` which returns `true` if the provided type is a system type alias (such as `size_t` or `ssize_t`), `false` otherwise
* MetaProcessor
- Implemented `isTypeAlias(string)` which determines if the given type is a type alias.
- Implemented `getConcreteType(string typeAlias)` which transforms the type alias into its
concrete type; this method incorporates defensive programming in that it will only apply the transformation IF
the provided type alias is infact a type alias, otherwise it performs an identity transformation
and returns the "alias" untouched.
* TypeChecker
- Clean up
* MetaProcessor
- `doTypeAlias(Container, Statement)` now makes use of `isTypeAlias(string)` and `getConcreteType(string)`
* - `typeRewrite(MTypeRewritable)` now makes use of `isTypeAlias(string)` and `getConcreteType(string)`
* MetaProcessor
- Cleaned up
* MetaProcessor
- Removed unused import
* MetaProcessor
- Removed now-completed TODO
* MetaProcessor
- Updated comment before call to `doTypeAlias(Container, Statement)`
* Containers
- `Module` now applies re-parenting in its `replace()`
- `Struct` now applies re-parenting in its `replace()`
- `Clazz` now applies re-parenting in its `replace()`
Data
- `Function` now applies re-parenting in its `replace()`
* Test cases
- Added `simple_template_type_def.t` for future test cases
* - Updated `.gitignore`
* Check
- Removed `SymbolType.REPR` which was used for testing early versions of the `MetaProcessor`
* Mcro
- Removed `Repr` which was used for testing in the early stages of `MetaProcessor`
* Check
- Removed reference to `SymbolType.REPR` in checker
* Parser
- Removed reference to `SymbolType.REPR` and `Repr` which was used for testing the `MetaProcessor` in early stages
* 🧹️🧼️ Cleanup: Clean up series 1 (#16)
* ⚡️ Feature: Lexer Interface cleanup (#14)
* LexerInterface
Defined the lexer interface
* Parser
- Fixed import for `Token` class
- Removed the token management fields such as `tokens`, `currentToken` and `tokenPtr` as these are now replaced by our `LexerInterface`, `lexer` field which manages this all for us
- Removed constructor which accepts a `Token[]`, now onyl accept a `LexerInterface`
- Removed `nextToken()`, `hasTokens()`, `getCurrentToken()`, `previousToken()`, `setCursor(ulong)` and `getCursor()`.
- The above now are called via the `lexer` instance
Parser (unit tests)
- Migrated to new `LexerInterface`+`BasicLexer` system
- Hoisted out common imports for unit tests into a `version(unittest)`
TypeChecker (unittests)
- Hoisted out common imports for unit tests into a `version(unittest)`
- Migrated to new `LexerInterface`+`BasicLexer` system
LexerInterface
- Moved to new `lexer.core` package
- Documented module and class
Commands
- Fixed imports for the (now) `BasicLexer`
- Fixed imports for the (now) `lexer.core` package
Compiler
- Fixed imports for the (now) `BasicLexer`
- Use `LexerInterface` instead of `Lexer`
- The `doLex()` method now uses an instance of `BasicLexer` and then downcasts to quickly call `performLex()` in order to tokenize and make them available
- The `doParse()` method now takes in an instance of `LexerInterface` rather than `Token[]`
BasicLexer (previously Lexer)
- Moved to the `lexer.kinds` package
- Now implements `LexerInterface`
- Documented module and class
- Documented the `LexerInterface` methods
Exceptions
- Moved to the `lexer.core` package
- Fixed import of `Token` class
- Now uses `LexerInterface`
Core.Lexer.Package
- Documented package module
Tokens
- Moved to the `lexer.core` package
- Documented module and class
Check
- Fixed import for `Token`
- Fixed import for `BasicLexer`
* `core.lexer` (package)
- Documented all public imports
* Exceptions
- Documented the module
- Documented `LexerError` and its members
- Documented `LexerException`, its members too
* Tokens
- Documented the fields (using proper syntax)
- Documented constructor and methods
* BasicLexer
- Removed now-completed TODO
- Added (for clarity) `override` keywords to the `getLine()` and `getColumn()` methods
- Moved `getLine()`, `getColumn()` and `getTokens()` altoghether
- Made `getTokens()` override-marked
- Documented `getTokens()`
* Check
- Removed weird TODO that makes no sense
- Documented some of the members of `SymbolType`
* Check
- Documented a few more enum members of `SymbolType`
- Fixed documentation (and added a TODO) for the `SymbolType.LE_SYMBOL`
* Check
- Documented a few more enum members of `SymbolType`
* Check
- Documented `isType(string)`
- Added a TODO for `isTYpe(string)` to "Check if below is even used
- Documented `isPathIdentifier(string)`
* Check
- Updated description of `isPathIdentifier(string)` to note it can contain underscores
- Documented isIdentifier(string)`
- Updated `SymbolType.IDENT_TYPE` to acknowledge underscores
- Documented `isAccessor(Token token)` and `isModifier(Token)`
* Check
- Documented `isIdentifier_NoDot(Token tokenIn)`, `isIdentifier_Dot(Token tokenIn)`, `isNumericLiteral(string token)`
- Removed uneeded import of `BasicLexer`
- Moved import to the top of file
* Check
- Documented `getSymbolType(Token tokenIn)`, `isMathOp(Token token)`, `isBinaryOp(Token token)`
* Check
- Documented the `symbols.check` module
* Builtins
- Properly documented `getBuiltInType(TypeChecker, string)`
* Builtins
- Documented module
* Typing (core)
- Documented module
- Documented all members
* Exceptions (lexer)
- Fixed documentation missing parameters
* Check
- Make comments docs/ddox compatible
* BasicLexer
- Fixed parameter name in documentation
* BasixLexer
- Fixed formatting in documentation for class
* Typing (core)
- Documented all remaining class members and fields
* - Update `.gitignore`
* Commands
- Handle `Exception` as well, I know DGen emits this on CC error so we should DO this to make tests more accurate
* Commands
- Fixed variable usage
* Instructions
- Made `BinOpInstr`'s left-hand side instruction of type `Value` and right-hand side instruction of type `Value` too
- Doesn't make sense to use anything but `Value`-based instructions for it
* Containers
- Removed redundant import that causes compilation failure on `ldc2`
* 🐞️ Functions: Expressionless return and enforcing requirement (#7)
* Parser
- Added a TODO in `parseReturn()` for issue #113
* Data
- The `ReturnStmt` now has a default constructor which is for cases where one doesn't want to provide an expression (for expressionless returns)
Parser
- `parseReturn()` now supports expressionless returns
Test cases
- Added `simple_return_expressionless.t` to test expressionless return statement
* Data
- Added a method `hasReturnExpression()` to `ReturnStmt` which returns `true` if the return statement has an expression attached, `false` otherwise
* Dependency
- When processing a `ReturnStmt` only run do dependency generation for the return statement's expression IF it has one
* Instruction
- Made `ReturnInstruction` have a constructor which takes in no `Value` instruction (intended for return expression)
- Added a `hasReturnExpInstr()` to `ReturnInstruction`such that during typechecking/codegen we can check for it
* TypeChecker
- Added a TODO regarding the missing typechecking for `ReturnStmt` typechecking. Added notes on how we'd go about this.
- Fixed crash due to assuming there was always an expression on the stack that could be popped off for generating a `ReturnInstruction` (this is not the case when the return statement is expressionless)
* Tests
- Added a typecheck test for `simple_return_expressionless.t`
* TypeChecker
- Update `isSameType(Type t1, Type t2)` to check if the actual types of both `Type` objects are the same as a last resort
- Added a `NOTE` comment on how `isSameType(Type t1, Type t2)` is implemented
- Added typechecking code for `ReturnStmt` and updated the code generation with it. We now do the following:
1. We extract the container of the `ReturnStmt` and cast it to a `Function`; if it is not a `Function` we throw an error because you cannot have a `ReturnStmt` appear in a non-`Function` container
2. We extract the function's name relative to it container (the function's container) for use of it in error messages
3. Next, we get the return type of the function and do the following:
a. If the return type is `void`
i. If the return has an expression we throw an error
ii. If the return has NO expression we pass typechecking and generate the `ReturnInstr`
b. If the return type is non-`void`
i. If the return has an expression we ensure that its type matches that of the function's return type and generate the `ReturnInstr`
ii. If the return has NO expression we raise an exception as one is expected
4. If we pass and got here then we set the `ReturnInstr`'s context and `addInstrB(returnInstr)`
* Test cases
- Added test case `simple_return_type.t` which is here to test our return type checking
* - Updated `.gitignore`
* Parser
- Use `lexer` for all `Token`-based operations
* Resolution
- Implemented `findContainerOfType(TypeInfo_Class, Statement)` which, given a type-of `Container` and a starting `Statement` (AST node) this will swim upwards to try and find the first matching parent of which is of the given type (exactly, not kind-of).
* TypeChecker
- Fixed the `Function` `Container` resolution for the `ReturnStmt` to now find the nearest `parent` in its parenthood tree which is a `Function`, extract the `Function`'s name and then use that where needed
* 🐞 Bugfix: Ensure that typed functions contain a return statement (#17)
* Parser
- Added TODO for checking for non-`void` function's return statements
* Parser
- If a `ReturnStmt` is not found after calling `parseFuncDef()`
* Parser
- Added a FIXME comment that needs to be completed soon
* Parser
- Only check that a `ReturnStmt` is present in a function definition when `wantsBody` is true ELSE we'd expect it for `efunc` `extern`'d statements
- Fixed a unit test which had a missing `return <expr>`
- Added a unit test which tests for a function definition with a body with a non-void return type that it DOES fail
- Removed two now-completed TODOs and FIXMEs
Test cases
- Fixed test case in `typecheck/simple_function_call.t` to now include the required `return <expr>` statements
* 🐞 Bugfix: Recursively check for return statemen tprescence (#19)
* Parsing
- Added a TODO for where the fix needs to be
* Parser
- Implemented `findOfType(TypeInfo_Class statementType, Container from)` which given a type of `Statement` to look for and a `Container` of which to search with in. This method will recursively search down the given container and look for any statements which are a kind-of (`isBaseOf`) the requested type. it will return an array of `Statement` (`Statement[]`) of the matches.
- Implemented `existsWithin(TypeInfo_Class statementType, Container from)` given a type of `Statement` to look for and a `Container` of which to search with in. This method will recursively search down the given container and look for any statements which are a kind-of (`isBaseOf`) the requested type. It will return `true` if any matches are found.
- We now will recursively explore the `Function`'s body statements in search of a `ReturnStmt`
* Parser (unit tests)
- Updated unit test which was meant to check for a greater number of body statements of the `Function` at question
* Parser (unit tests)
- Because this causes `expect(string)` to be called (this unit test) we must catch `TError` as that is what `expect(string)` throws
- We should update this (see https://deavmi.assigned.network/git/tlang/tlang/issues/147)
* Tets cases
- Added missing `return` to function `banana` in `simple_functions.t` test case
* Test cases
- Fixed `simple_function_decls.t` to include the required (but missing) `return` statement
* 🐞 Bugfix: expect(string) should throw ParserException atleast (#20)
* Parser
- Removed commented-out code
* Parser
- Removed `isUnitTest` variable and how `expect(string)` relies on it
* Parser
- Now throw a new `ParserException` instead of a `TError` when calling `expect(string)`
* Parser
- Made `expect(string)` not static
* TypeChecker
- Implemented `expect(string)` which throws a `TypeCheckerException` in a similar fashion to `Parser`'s `expect(string)`
* Dependency
- Implemented `expect(string)` which throws a `DependencyException` in a similar fashion to `Parser`'s `expect(string)`
Exceptions (dependency)
- Added enum member `GENERAL_ERROR` to `DependencyError`
* Parser (unit tests)
- Made more specific
* Parser
- Removed now-completed TODO
* Data
- Removed unused type `ArgumentList`
* Expressions
- Made the `Expression` class abstract
- Removed irrelevant TODOs and method
- Removed uneeded constructor
VariableExpression
- Removed unused junk
* 🧠 Feature/Meta: Cloneable (round 1) (#21)
* Data
- Moved AST manipulation imports to the top
- Made `VariableAssignment` cloneable
- Made `Variable` cloneable
* Data
- When trying to `clone()` an `Expression`, do a runtime type check to check if we can (else `null` is used)
* Expressions
- Moved AST-manipulation related import to the top
* Expressions
- `BinaryOperatorExpression` now overrides `clone()` from `MCloneable`
* Expressions
- `IntegerLiteral` now implements `MCloneable`
* Expressions
- `CastedExpression` now implements `clone()` for `MCloneable`
* Containers
- Moved all AST maniuplation-related imports to the top
* Containers
- Made `Struct` support `MCloneable`'s `clone()` method
* Data
- Only clone the `VariableAssignment` if the `Variable` has one
* Containers (unit test)
- Added test which tests the `clone()` on a `Struct`
* DGen
- If `typeTransform(Type)` fails then the debug text should be in the error coloring
* DGen
- If `typeTransform(Type)` is called on an unknown type then print out the type in the error message asx well
* Mcro
- Made `MCloneable`'s `clone()` require a `Container` argument of which the final cloned `Statement` must parent-itself to
* Expressions
- `BinaryOperatorExpression`, `CastedExpression` and `IntegerLiteral` now implements the new `MCloneable` API
* Expressions
- Added notes about where parenting must manually be done
* Data
- `Variable` and `VariableAssignment` now uses the new `MCloneable` API
* Containers
- `Struct`'s `MCloenable` API adhered to
* Containers
- Fixed `clone(Container)` implementation for `Struct` whereby it would not parent the newly created copy
* TypeChecker
- Added a TODO regarding the `ClassStaticNode` handling
* TypeCheck
- Undo incorrect FIXME
* CodeEmitter
- Added a new parameter to `transform(Instruction)` (now `transform(Instruction, Object)`. `customRules` is an `Object` to be interpreted by the underlying emitter which can change how certain transformations are done when it is in a certain state
DGen
- Uses new `CodeEmitter` API
* Revert "CodeEmitter"
This reverts commit 75372ee132.
* DGen
- Added ability to flag whether symbol mapping should occur or not
- By default enable symbol mapping
* Variable
- When calling `replace(Statement, Statement)`, if we hit the `variableAssignment` replacement check, first check and ensure it is not null`, try
* 🧠️ Feature: Universal coercion and type enforcer (#9)
* TypeChecker
- Added `bool isSameType2(Value v1, Value v2, bool attemptCoercion = false)` for future implementation of universal coercion as per #115
* TypeChecker
- Renamed `isSameType2` to `typeEnforce`
- Updated `typeEnforce`'s default parameter documentation from `false` to `attemptCoercion` (as it should have been in the beginning)
* TypeCheckerException
- Save the `TypecheckError` coming in as `errType` and make it available via `getError()`
TypemMismatchException
- Save the original (expected) and attempted types and make them available via `getExpectedType()` and `getATtemptedType()` respectively
* TypeChecker
- Updated `typeEnforce` from taking in `Value v1, Value v2, bool` to `Type t1, Value v2, bool`.
- `typeEnforce()` will now extract the `Type` of `Value v2` and call `isSameType(t1, t2)`, if that fails and coercion is allowed then it is attempted, however if that fails then it causes an exception to be thrown. In the case coercion is not allowed, then a `TypeMismatchException` is thrown
Unit tests
- Tested the new `typeEnforce(Type t1, Value v2, bool)` and it seems to work, both a case of failing matching (coercion disallowed) and working coercion (coercion allowed)
* TypeChecker
- Documented existing unittest for `typeEnforce(Type, Value, bool)`
- Added new unit test for `typeEnforce(Type, Value, bool)` which tests when the types ARE the same
* TypeChecker
- Cleaned up `typeEnforce(Type, Value, bool)`
* TypeChecker
- Added a work-in-progress unit test to test how I would use `typeEnforce(Type t1, Value v2, bool coercion = false)` in practice
- Added TODOs in `attemptCoercion(Type, Type)` where I must add support
* TypeChecker
- Finished the unit test testing out the usage for `typeEnforce(Type, Value, bool coerce = false)`
- Added TODOs to `attemptCoercion(Type, Value)` for the changes required to it
* TypeChecker
- Removed incorrect TODOs from `attemptCoerce(Type, Value)` and updated the message when the coercion fails
Unit tests
- Updated first unit test for `typeEnforce()` to test failing coercion on a non-`LiteralValue` instruction
- Added a unit test where `typeEnforce()` WILL pass as it coerces a `LiteralValue` instruction
* Exceptions (`typechecker`)
- Added new exception type `CoercionException` to be thrown whenever a coercion cannot take place.
* TypeChecker
- Ensure that `attemptCoercion(Type, Value)` only throws instances of `CoercionException`
* Unit tests
- Fixed failing-coercion check by catching the correct exception when it fails `CoercionException` instead of `TypeMismatchException`)
* TypeChecker
- Added documentation for `isSameType(Type t1, Type t2)`
* TypeChecker
- Updated documentation for `isCoercibleRange(Type, Value)`
- Updated `attemptCoercion(Type, Value)` with new documentation and renamed parameters
* Unit tests (typechecker)
- Added comments
* TypeChecker
- Removed now-completed TODO in `typeEnforce(Type t1, Value v2, bool allowCoercion = false)`
* TypeChecker
- Removed unused `typeStatus` variable in `typeEnforce(Type, Value, bool)`
* TypeChecker
- Variable declarations (with assignments) now use the `typeEnforce()` method with coercion allowed in order to do the type checking and coercion changes
- Added a comment explaining a certain branch of `attemptCoercion(Type, Value)`
* TypeChecker
- If the to-type and provided-type are both numerical then use a size-based test
Test cases
- Added two test cases which test `typeEnforce()` on incoming `Value`-based instructions as part of variable declarations
* Test cases
- Fixed negative test case - it MUST have an error and that should be seen as a pass
* TypeChecker (unit tests)
- Disabled invalid unit test (marked for re-writing)
- I should re-write the below. It is now incorrect as I DO ALLOW coercion of non literal-based instructions now - so it fails because it is using an older specification of TLang
* TypeChecker
- Migrated the type checking of standalone variable assignments to using `typeEnforce()`
Test cases
- Added positive and negative test cases
* - Updated `.gitignore`
* Feature/type enforcer cast instr emit (#13)
* TypeChecker
- `typeEnforce()` now will not change the type of `Value`-based instruction `v2` but rather return, on successful coercion set a `ref`-based argument to a new instance of a `CastedValueInstruction`, if coercion fails or was disabled and types mismatched then an exeption is thrown as normal.
- If the types are an exact same match, a-la `isSameType(Type, Type)`, then this `ref` value is set to `v2` (makes programming easy) else we would have no way to know
- `attemptCoerce()` now, to go with the above changes to `typeEnforce()`, returns a `CatsedValueInstruction` to the to-type on successful coercion, else an exception is thrown as usual
- Updated two cases of `typeEnforce()` usage to the new method signature, also now add a sanity check assertion that the types now DO match as they should
* TypeChecker
- We need not set it again, look the value we use when we CALL `typeEnforce()` is that of the `fromInstruction` and if no changes occur we still have it, it is fine - if it changes via the call to `typeEnforce()` via the `ref` based argument thne same old
- No need for us to set it here in the event of no changes, we are writing back the exact same Instruction/object-reference
* TypeChecker (unit tests)
- Upgraded to the new `typeEnforcer()` method signature
* TypeChecker
- Improved documentation for `typeEnforce()`
* TypeChecker
- Added TODO regarding pointer coercion with integers in `Pointer + Integer` case (for pointer airthmetic)
* TypeChecker
- Added a new branch which currently throws an exception as it is unimplememted
- This branch (above) is in `attemptCoercion()` and is to handle the coercion of `Integer` to `Pointer` for pointer arithmetic
- When doing the typechecking/codegen for `BinaryOp`, disable the pointer coercion call to `attemptPointerAriehmeticCoercion()`, instead now make calls in those cases they apply, to `typeEnforce()`
- The above stuff is still broken, not yet implemented.
* TypeChecker
- Cannot use cast as that can return false positives for an all pointer case as all `Pointer`s are `Integer`s
- Added `isPointerType(Type)` to check the above
- Added then also `isIntegralTypeButNotPointer(Type)` which checks for an `Integer` type but excluding if it is a `Pointer`
- Updated the checks in the `BinaryOperator` branch of `typeCheckThing(DNode)` to do this
* TypeChecker
- Need to do the `Pointer` checks first in `attemptCoercion(Type, Value)`
* TypeChecker
- `attemptCoercion(Type, Value)` now returns a `CastedValueInstruction` to cast the `Integer` type to the `Pointer` type
* TypeCHecker
- Catch mis use of type enforcement by using `isIntegralTypeButNotPointer(Type)` and isPointerType`(Type)` for the previous commit
* TypeChecker
- Refresh the types after the potential calls to `typeEnforce(..., ..., ..., ...)`
* Pipeline
- Use `set -e` for `simple_pointer.t` test in emit stage
* Pipelines (emit stage)
- Previous compilation may have succeeded, meaning ./tlang.out never gets updated and exits fine with 0, but we only use the last commands exit status to check for a pass for a test.
- By setting this if COMPILATION fails then we exit with its code and the test status is set via that
* Pipelines
- Removed the `set -e` code as the correct `Exception` now causes a non-zero exit code from the changes made in `varass_vardec_dependency`
* DGen
- Added notice for issue #140
* TypeChecker
- Made `isIntegralTypeButNotPointer(Type)` public
- Made `isPointerType(Type)` public
* Instructions
- `CastedValueInstruction` now is unrelaxed by default but can be set (tis aids in how it can be emitted later for issue #140)
* DGen
- Added some checks for certain conditions whereby pointer coercion requires relaxing the casted operands (coerced operands)
* DGen
- Relax `CastedValueInstruction`(s) when appropriate in `BinaryOpInstr` handling code
- Removed panics
* DGen
- Added relaxation support to the code emitting code for `CastedValueInstruction`
* DGen
- make debug messages for when relaxation occurs for `CastedValueInstruction` emitting more clear
* TypeChecker
- Implemented `biggerOfTheTwo(Integer, Integer)` which determines the biggest of the two `Integer`-based types and returns that one.
* TypeChecker
- Fixed incorrect variable name in `biggerOfTheTwo(Integer, Integer)`
* TypeChecker
- Throw an error in the case where a `BinaryOperatorExpression` occurs with non-`Integer`-based instructions (at least for now)
* TypeChecker
- If both types are `Integral` (but not `Pointer`) then smaller coerces to bigger, if they however are equal then signed coerces to unsigned
* TypeChecker
- Removed now irrelevant comment
* TypeChecker
- Don't throw exception here, rather let the `isSameType(Type, Type)` check handle that
- We still keep the warning we print about missing cases implementation-wise
* TypeChecker
- Fixed explanation
* TypeChecker
- Marked related issue
* TypeChecker
- Implemented ` isStackArrayType(Type typeIn)`
- WIP: Added a check for handling `StackArray -> Pointer` coercion to `attemptCoercion(Type, Value)`
* TypeChecker
- `attemptCoercion(Type, Value)` will now ensure firstly that the `StackArray`'s component type matches that of the `Pointer`'s referred type, if not throw an exception, if so, then return a `CastedValueInstruction`
* TypeChecker
- Print out a debug message when attempting to coerce a `StackArray` to a `Pointer`
- Fixed the error message thrown when a `StackArray` could not be coerced to a `Pointer` due to the component type != ptr's referred type
- `FunctionCall` handling now has the `canCoerceStackArray()` code disabled and uses the `typeEnforce()` method
* TypeChecker
- Type checking code for `FunctionCall`
* TypeCheck
- Completed TODO comment
* TypeChecker
- Added a TODO
* TypeChecker
- Added FIXME where the `typeEnforce()` call need to be made for the `ReturnStmt`'s return expression's type to match or be checked-against the containing `Function`'s
* TypeChecker
- `ReturnStmt` now uses `typeEnforce()`
* Test cases
- Added two new checks for checking the return type of a function and matching a `ReturnStmt`'s expression's type to it
* TypeChecker
- Removed assertion check, rather let the exception thrown handle the error
- Only after we know the finally-parenting `Container` is a `Function` (should we reference `funcContainer`
* Test cases
- Removed explicit cast from `simple_function_recursion_factorial.t`
* TypeChecker
- If we have a `LiteralValue` and a non-`LiteralValue` then coerce the `LiteralValue` towards the non`-LiteralValue` via `typeEnforce()`
- This should allow the correct range checking of literal values within the range of the to-type and not require annoying explicit casts
* Test cases
- Removed now-unneeded explicit casts on literal values in `simple_function_recursion_factorial.t`
* TypeChecker
- Added comment describing the process used
- Removed now-completed TODO
* TypeChecker
- Removed some dead code
- Removed now-completed FIXME/TODO
* TypeChecker
- Removed old type checking code for variable declarations with assignments
- Removed old type checking code for standalone variable assignments
* Dub
- Upgraded `jcli` to version `0.25.0-beta.2`
* Dub
- Upgtraded package `jcli` to version `0.25.0-beta.3`
* - Try using latest version of `dmd`
master
GitHub
parent
e5610be6f2
commit
01afa43e93
Binary file not shown.
|
After Width: | Height: | Size: 428 KiB |
Binary file not shown.
Binary file not shown.
|
After Width: | Height: | Size: 194 KiB |
Binary file not shown.
@ -0,0 +1,74 @@
|
||||
/**
|
||||
* Exception definitions
|
||||
*/
|
||||
module tlang.compiler.lexer.core.exceptions;
|
||||
|
||||
import misc.exceptions : TError;
|
||||
import tlang.compiler.lexer.core.lexer : LexerInterface;
|
||||
import std.conv : to;
|
||||
|
||||
/**
|
||||
* The specified error which occurred
|
||||
*/
|
||||
public enum LexerError
|
||||
{
|
||||
/**
|
||||
* If all the characters were
|
||||
* exhausted
|
||||
*/
|
||||
EXHAUSTED_CHARACTERS,
|
||||
|
||||
/**
|
||||
* Generic error
|
||||
*/
|
||||
OTHER
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents an exception that can occur
|
||||
* when using a `LexerInterface`
|
||||
*/
|
||||
public final class LexerException : TError
|
||||
{
|
||||
/**
|
||||
* The offending `LexerInterface` instance
|
||||
*/
|
||||
public const LexerInterface offendingInstance;
|
||||
|
||||
/**
|
||||
* The sub-error type (specific error)
|
||||
*/
|
||||
public const LexerError errType;
|
||||
|
||||
/**
|
||||
* Constructs a new `LexerException` with the given offending instance
|
||||
* where the error occured from and the default error type and no
|
||||
* custom message
|
||||
*
|
||||
* Params:
|
||||
* offendingInstance = the offending `LexerInterface`
|
||||
* errType = the sub-error type as a `LexerError`
|
||||
* msg = the custom message (default is empty/`""`)
|
||||
*/
|
||||
this(LexerInterface offendingInstance, LexerError errType = LexerError.OTHER, string msg = "")
|
||||
{
|
||||
string positionString = "("~to!(string)(offendingInstance.getLine())~", "~to!(string)(offendingInstance.getColumn())~")";
|
||||
super("LexerException("~to!(string)(errType)~")"~(msg.length ? ": "~msg : "")~" at "~positionString);
|
||||
this.offendingInstance = offendingInstance;
|
||||
this.errType = errType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a new `LexerException` with the given offending instance
|
||||
* where the error occured from and the default error type and a
|
||||
* custom message
|
||||
*
|
||||
* Params:
|
||||
* offendingInstance = the offending `LexerInterface`
|
||||
* msg = the custom message
|
||||
*/
|
||||
this(LexerInterface offendingInstance, string msg)
|
||||
{
|
||||
this(offendingInstance, LexerError.OTHER, msg);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
/**
|
||||
* Lexer interface definition
|
||||
*/
|
||||
module tlang.compiler.lexer.core.lexer;
|
||||
|
||||
import tlang.compiler.lexer.core.tokens : Token;
|
||||
|
||||
/**
|
||||
* Defines the interface a lexer must provide
|
||||
* such that is can be used to source tokens
|
||||
* from in the parser
|
||||
*/
|
||||
public interface LexerInterface
|
||||
{
|
||||
/**
|
||||
* Returns the token at the current cursor
|
||||
* position
|
||||
*
|
||||
* Returns: the `Token`
|
||||
*/
|
||||
public Token getCurrentToken();
|
||||
|
||||
/**
|
||||
* Moves the cursor one token forward
|
||||
*/
|
||||
public void nextToken();
|
||||
|
||||
/**
|
||||
* Moves the cursor one token backwards
|
||||
*/
|
||||
public void previousToken();
|
||||
|
||||
/**
|
||||
* Sets the position of the cursor
|
||||
*
|
||||
* Params:
|
||||
* cursor = the new position
|
||||
*/
|
||||
public void setCursor(ulong cursor);
|
||||
|
||||
/**
|
||||
* Retrieves the cursor's current position
|
||||
*
|
||||
* Returns: the position
|
||||
*/
|
||||
public ulong getCursor();
|
||||
|
||||
/**
|
||||
* Checks whether more tokens are available
|
||||
* of not
|
||||
*
|
||||
* Returns: true if more tokens are available, false otherwise
|
||||
*/
|
||||
public bool hasTokens();
|
||||
|
||||
/**
|
||||
* Get the line position of the lexer in the source text
|
||||
*
|
||||
* Returns: the position
|
||||
*/
|
||||
public ulong getLine();
|
||||
|
||||
/**
|
||||
* Get the column position of the lexer in the source text
|
||||
*
|
||||
* Returns: the position
|
||||
*/
|
||||
public ulong getColumn();
|
||||
|
||||
/**
|
||||
* Exhaustively provide a list of all tokens
|
||||
*
|
||||
* Returns: a `Token[]` containing all tokens
|
||||
*/
|
||||
public Token[] getTokens();
|
||||
}
|
||||
@ -0,0 +1,19 @@
|
||||
/**
|
||||
* Base definitions relating to the lexer
|
||||
*/
|
||||
module tlang.compiler.lexer.core;
|
||||
|
||||
/**
|
||||
* Lexer interface definition
|
||||
*/
|
||||
public import tlang.compiler.lexer.core.lexer;
|
||||
|
||||
/**
|
||||
* Token definition
|
||||
*/
|
||||
public import tlang.compiler.lexer.core.tokens;
|
||||
|
||||
/**
|
||||
* Exception definitions
|
||||
*/
|
||||
public import tlang.compiler.lexer.core.exceptions;
|
||||
@ -0,0 +1,76 @@
|
||||
/**
|
||||
* Token definition
|
||||
*/
|
||||
module tlang.compiler.lexer.core.tokens;
|
||||
|
||||
import std.string : cmp;
|
||||
import std.conv : to;
|
||||
|
||||
/**
|
||||
* Defines a `Token` that a lexer
|
||||
* would be able to produce
|
||||
*/
|
||||
public final class Token
|
||||
{
|
||||
/**
|
||||
* The token
|
||||
*/
|
||||
private string token;
|
||||
|
||||
/**
|
||||
* Line number information
|
||||
*/
|
||||
private ulong line, column;
|
||||
|
||||
/**
|
||||
* Constructs a new `Token` with the given
|
||||
* contents and line information
|
||||
*
|
||||
* Params:
|
||||
* token = the actual string
|
||||
* line = the line it occurs at
|
||||
* column = the column it occurs at
|
||||
*/
|
||||
this(string token, ulong line, ulong column)
|
||||
{
|
||||
this.token = token;
|
||||
this.line = line;
|
||||
this.column = column;
|
||||
}
|
||||
|
||||
/**
|
||||
* Overrides the `==` operator to do equality
|
||||
* based on the stored token's contents
|
||||
*
|
||||
* Params:
|
||||
* other = the other `Token` being compared to
|
||||
* Returns: true if the contents of the two tokens
|
||||
* match, false otherwise
|
||||
*/
|
||||
override bool opEquals(Object other)
|
||||
{
|
||||
return cmp(token, (cast(Token)other).getToken()) == 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Rerturns a string representation of the token including
|
||||
* its data and line information
|
||||
*
|
||||
* Returns: a `string`
|
||||
*/
|
||||
override string toString()
|
||||
{
|
||||
/* TODO (Column number): Don't adjust here, do it maybe in the lexer itself */
|
||||
return token~" at ("~to!(string)(line)~", "~to!(string)(column-token.length)~")";
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the token's contents
|
||||
*
|
||||
* Returns: a `string`
|
||||
*/
|
||||
public string getToken()
|
||||
{
|
||||
return token;
|
||||
}
|
||||
}
|
||||
@ -1,30 +0,0 @@
|
||||
module tlang.compiler.lexer.exceptions;
|
||||
|
||||
import misc.exceptions : TError;
|
||||
import tlang.compiler.lexer.core : Lexer;
|
||||
import std.conv : to;
|
||||
|
||||
public enum LexerError
|
||||
{
|
||||
EXHAUSTED_CHARACTERS,
|
||||
OTHER
|
||||
}
|
||||
|
||||
public final class LexerException : TError
|
||||
{
|
||||
public const Lexer offendingInstance;
|
||||
public const LexerError errType;
|
||||
|
||||
this(Lexer offendingInstance, LexerError errType = LexerError.OTHER, string msg = "")
|
||||
{
|
||||
string positionString = "("~to!(string)(offendingInstance.getLine())~", "~to!(string)(offendingInstance.getColumn())~")";
|
||||
super("LexerException("~to!(string)(errType)~")"~(msg.length ? ": "~msg : "")~" at "~positionString);
|
||||
this.offendingInstance = offendingInstance;
|
||||
this.errType = errType;
|
||||
}
|
||||
|
||||
this(Lexer offendingInstance, string msg)
|
||||
{
|
||||
this(offendingInstance, LexerError.OTHER, msg);
|
||||
}
|
||||
}
|
||||
@ -1,36 +0,0 @@
|
||||
module tlang.compiler.lexer.tokens;
|
||||
|
||||
import std.string : cmp;
|
||||
import std.conv : to;
|
||||
|
||||
public final class Token
|
||||
{
|
||||
/* The token */
|
||||
private string token;
|
||||
|
||||
/* Line number information */
|
||||
private ulong line, column;
|
||||
|
||||
this(string token, ulong line, ulong column)
|
||||
{
|
||||
this.token = token;
|
||||
this.line = line;
|
||||
this.column = column;
|
||||
}
|
||||
|
||||
override bool opEquals(Object other)
|
||||
{
|
||||
return cmp(token, (cast(Token)other).getToken()) == 0;
|
||||
}
|
||||
|
||||
override string toString()
|
||||
{
|
||||
/* TODO (Column number): Don't adjust here, do it maybe in the lexer itself */
|
||||
return token~" at ("~to!(string)(line)~", "~to!(string)(column-token.length)~")";
|
||||
}
|
||||
|
||||
public string getToken()
|
||||
{
|
||||
return token;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,17 @@
|
||||
module tlang.compiler.parsing.cloneable;
|
||||
|
||||
import tlang.compiler.symbols.data : Statement;
|
||||
|
||||
/**
|
||||
* A parse-node/AST-node which implements `Cloneable` can
|
||||
* be safely deeply cloned such that a full copy is returned.
|
||||
*/
|
||||
public interface Cloneable
|
||||
{
|
||||
/**
|
||||
* Performs a deep clone of this parse node
|
||||
*
|
||||
* Returns: the clone
|
||||
*/
|
||||
public Statement clone();
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,70 @@
|
||||
module tlang.compiler.symbols.mcro;
|
||||
|
||||
import tlang.compiler.symbols.data;
|
||||
|
||||
public class Macro : Statement
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public interface MTypeRewritable
|
||||
{
|
||||
public string getType();
|
||||
public void setType(string type);
|
||||
}
|
||||
|
||||
/**
|
||||
* Anything which implements this has the ability
|
||||
* to search for objects of the provided type,
|
||||
* and return a list of them
|
||||
*/
|
||||
public interface MStatementSearchable
|
||||
{
|
||||
/**
|
||||
* Searches for all objects of the given type
|
||||
* and returns an array of them. Only if the given
|
||||
* type is equal to or sub-of `Statement`
|
||||
*
|
||||
* Params:
|
||||
* clazzType = the type to search for
|
||||
* Returns: an array of `Statement` (a `Statement[]`)
|
||||
*/
|
||||
public Statement[] search(TypeInfo_Class clazzType);
|
||||
}
|
||||
|
||||
/**
|
||||
* Anything which implements this has the ability
|
||||
* to, given an object `x`, return a `ref x` to it
|
||||
* hence allowing us to replace it
|
||||
*/
|
||||
public interface MStatementReplaceable
|
||||
{
|
||||
/**
|
||||
* Replace a given `Statement` with another `Statement`
|
||||
*
|
||||
* Params:
|
||||
* thiz = the `Statement` to replace
|
||||
* that = the `Statement` to insert in-place
|
||||
* Returns: `true` if the replacement succeeded, `false` otherwise
|
||||
*/
|
||||
public bool replace(Statement thiz, Statement that);
|
||||
}
|
||||
|
||||
/**
|
||||
* Anything which implements this can make a full
|
||||
* deep clone of itself
|
||||
*/
|
||||
public interface MCloneable
|
||||
{
|
||||
/**
|
||||
* Returns a `Statement` which is a clone of this one
|
||||
* itself
|
||||
*
|
||||
* Param:
|
||||
* newParent = the `Container` to re-parent the
|
||||
* cloned `Statement`'s self to
|
||||
*
|
||||
* Returns: the cloned `Statement`
|
||||
*/
|
||||
public Statement clone(Container newParent = null);
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,413 @@
|
||||
module tlang.compiler.typecheck.meta;
|
||||
|
||||
import tlang.compiler.symbols.data : Statement, TypedEntity, Function, FunctionCall, IdentExpression;
|
||||
import tlang.compiler.symbols.expressions : Expression, IntegerLiteral, IntegerLiteralEncoding;
|
||||
import tlang.compiler.symbols.typing.core;
|
||||
import tlang.compiler.symbols.containers : Container;
|
||||
import tlang.compiler.symbols.mcro;
|
||||
import tlang.compiler.typecheck.core;
|
||||
import gogga;
|
||||
import std.conv : to;
|
||||
import tlang.compiler.configuration;
|
||||
|
||||
/**
|
||||
* The `MetaProcessor` is used to do a pass over a `Container`
|
||||
* to process any macro and macro-like entities
|
||||
*/
|
||||
public class MetaProcessor
|
||||
{
|
||||
private TypeChecker tc;
|
||||
private bool isMetaEnabled;
|
||||
private CompilerConfiguration compilerConfig;
|
||||
|
||||
/**
|
||||
* Constructs a new `MetaProcessor` for the purposes of
|
||||
* modifying the AST tree before the typechecker traverses
|
||||
* it
|
||||
*
|
||||
* Params:
|
||||
* tc = the `TypeChecker` instance to process
|
||||
* isMetaEnabled = `true` if to perform meta processing, otherwise `false`
|
||||
*/
|
||||
this(TypeChecker tc, bool isMetaEnabled)
|
||||
{
|
||||
this.tc = tc;
|
||||
this.isMetaEnabled = isMetaEnabled;
|
||||
this.compilerConfig = tc.getConfig();
|
||||
}
|
||||
|
||||
/**
|
||||
* Analyzes the provided `Container` and searches for any `Macro`-like
|
||||
* parse-nodes to process
|
||||
*/
|
||||
public void process(Container container)
|
||||
{
|
||||
/* Only apply meta-processing if enabled */
|
||||
if(!isMetaEnabled)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/* Get all statements */
|
||||
Statement[] stmts = container.getStatements();
|
||||
|
||||
foreach(Statement curStmt; stmts)
|
||||
{
|
||||
gprintln("MetaProcessor: Examining AST node '"~curStmt.toString()~"'...");
|
||||
|
||||
// Perform replacement of all type alises to concrete types, such as `size_t`
|
||||
doTypeAlias(container, curStmt);
|
||||
|
||||
/**
|
||||
* Search for any `sizeof(<ident_type>)` expressions
|
||||
* and replace them with a `NumberLiteral`
|
||||
*/
|
||||
if(cast(MStatementSearchable)curStmt && cast(MStatementReplaceable)curStmt)
|
||||
{
|
||||
MStatementSearchable searchableStmt = cast(MStatementSearchable)curStmt;
|
||||
Statement[] foundStmts = searchableStmt.search(FunctionCall.classinfo);
|
||||
gprintln("Nah fr");
|
||||
|
||||
foreach(Statement curFoundStmt; foundStmts)
|
||||
{
|
||||
FunctionCall curFuncCall = cast(FunctionCall)curFoundStmt;
|
||||
|
||||
if(curFuncCall.getName() == "sizeof")
|
||||
{
|
||||
gprintln("Elo");
|
||||
Expression[] arguments = curFuncCall.getCallArguments();
|
||||
if(arguments.length == 1)
|
||||
{
|
||||
IdentExpression potentialIdentExp = cast(IdentExpression)arguments[0];
|
||||
if(potentialIdentExp)
|
||||
{
|
||||
string typeName = potentialIdentExp.getName();
|
||||
IntegerLiteral replacementStmt = sizeOf_Literalize(typeName);
|
||||
gprintln("sizeof: Replace '"~curFoundStmt.toString()~"' with '"~replacementStmt.toString()~"'");
|
||||
|
||||
/* Traverse down from the `Container` we are process()'ing and apply the replacement */
|
||||
MStatementReplaceable containerRepl = cast(MStatementReplaceable)container;
|
||||
containerRepl.replace(curFoundStmt, replacementStmt);
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: Throw an exception here that an ident_type should be present as the argument
|
||||
gprintln("The argument to `sizeof` should be an ident", DebugType.ERROR);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: Throw an exception here as only 1 argument is allowed
|
||||
gprintln("To use the `sizeof` macro you require a single argument to be passed to it", DebugType.ERROR);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* If the current statement is a Container then recurse
|
||||
*
|
||||
* This will help us do the following:
|
||||
*
|
||||
* 1. Type re-writing of
|
||||
* a. Functions (Parameters and Body as both make up its Statement[])
|
||||
*/
|
||||
if(cast(Container)curStmt)
|
||||
{
|
||||
process(cast(Container)curStmt);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Re-writes the types for things such as `size_t`, `ssize_t` and so forth
|
||||
*
|
||||
* Params:
|
||||
* statement = the `MTypeRewritable` to apply re-writing to
|
||||
*/
|
||||
private void typeRewrite(MTypeRewritable statement)
|
||||
{
|
||||
/* Applies re-write to Variable's declared type and Function's return type */
|
||||
string type = statement.getType();
|
||||
|
||||
/* Only re-write if type alias */
|
||||
if(isTypeAlias(type))
|
||||
{
|
||||
/* Get the concrete type of `type` */
|
||||
string concreteType = getConcreteType(type);
|
||||
|
||||
/* Rewrite the type */
|
||||
statement.setType(concreteType);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs the replacement of type alieses such as `size_t`, `ssize_t`
|
||||
* and so forth with their concrete type
|
||||
*
|
||||
* Params:
|
||||
* container = the current `Container` being processsed
|
||||
* curStmt = the current `Statement` to consider
|
||||
*/
|
||||
private void doTypeAlias(Container container, Statement curStmt)
|
||||
{
|
||||
/**
|
||||
* Apply type-rewriting to any `MTypeRewritable` AST node
|
||||
* (a.k.a. a node which contains a type and can have it set)
|
||||
*
|
||||
* NOTE: This is just for the "type" fields in AST nodes,
|
||||
* we should have some full recursive re-writer.
|
||||
*
|
||||
* An example of why is for supporting something like:
|
||||
*
|
||||
* `sizeof(size_t)` <- currently is not supported by this
|
||||
*/
|
||||
if(cast(MTypeRewritable)curStmt)
|
||||
{
|
||||
typeRewrite(cast(MTypeRewritable)curStmt);
|
||||
}
|
||||
|
||||
/**
|
||||
* Here we will also search for any `IdentExpression`
|
||||
* which contains `size_t`, `ssize_t` etc. and replace
|
||||
* them
|
||||
*/
|
||||
if(cast(MStatementSearchable)curStmt && cast(MStatementReplaceable)curStmt)
|
||||
{
|
||||
MStatementSearchable searchableStmt = cast(MStatementSearchable)curStmt;
|
||||
IdentExpression[] foundStmts = cast(IdentExpression[])searchableStmt.search(IdentExpression.classinfo);
|
||||
|
||||
// TODO: Implement me
|
||||
// gprintln("IdentExpressions found: "~to!(string)(foundStmts));
|
||||
|
||||
/**
|
||||
* Loop through all `IdentExpression`s and find any
|
||||
* occurence of `size_t`/`ssize_t` and replace those
|
||||
* with the concrete type
|
||||
*/
|
||||
foreach(IdentExpression identExp; foundStmts)
|
||||
{
|
||||
string identName = identExp.getName();
|
||||
|
||||
/* Determine if this is a type alias? */
|
||||
if(isTypeAlias(identName))
|
||||
{
|
||||
// Determine the concrete type
|
||||
string concereteType = getConcreteType(identName);
|
||||
gprintln("Found type alias '"~identName~"' which concretely is '"~concereteType~"'");
|
||||
|
||||
// Replace with concrete type
|
||||
container.replace(identExp, new IdentExpression(concereteType));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private IntegerLiteral sizeOf_Literalize(string typeName)
|
||||
{
|
||||
IntegerLiteral literal = new IntegerLiteral("TODO_LITERAL_GOES_HERESIZEOF_REPLACEMENT", IntegerLiteralEncoding.UNSIGNED_INTEGER);
|
||||
|
||||
// TODO: Via typechecker determine size with a lookup
|
||||
Type type = tc.getType(tc.getModule(), typeName);
|
||||
|
||||
/* Calculated type size */
|
||||
ulong typeSize = 0;
|
||||
|
||||
/**
|
||||
* Calculate stack array size
|
||||
*
|
||||
* Algo: `<componentType>.size * stackArraySize`
|
||||
*/
|
||||
if(cast(StackArray)type)
|
||||
{
|
||||
StackArray stackArrayType = cast(StackArray)type;
|
||||
ulong arrayLength = stackArrayType.getAllocatedSize();
|
||||
Type componentType = stackArrayType.getComponentType();
|
||||
ulong componentTypeSize = 0;
|
||||
|
||||
// FIXME: Later, when the Dependency Genrator supports more advanced component types,
|
||||
// ... we will need to support this - for now assume that `componentType` is primitive
|
||||
if(cast(Number)componentType)
|
||||
{
|
||||
Number numberType = cast(Number)componentType;
|
||||
componentTypeSize = numberType.getSize();
|
||||
}
|
||||
|
||||
typeSize = componentTypeSize*arrayLength;
|
||||
}
|
||||
/**
|
||||
* Calculate the size of `Number`-based types
|
||||
*/
|
||||
else if(cast(Number)type)
|
||||
{
|
||||
Number numberType = cast(Number)type;
|
||||
typeSize = numberType.getSize();
|
||||
}
|
||||
|
||||
// TODO: We may eed toupdate Type so have bitwidth or only do this
|
||||
// for basic types - in which case I guess we should throw an exception
|
||||
// here.
|
||||
// ulong typeSize =
|
||||
|
||||
|
||||
|
||||
/* Update the `Sizeof` kind-of-`IntegerLiteral` with the new size */
|
||||
literal.setNumber(to!(string)(typeSize));
|
||||
|
||||
return literal;
|
||||
}
|
||||
|
||||
/**
|
||||
* Transforms the type alias into its concrete type.
|
||||
*
|
||||
* This method incorporates defensive programming in
|
||||
* that it will only apply the transformation IF
|
||||
* the provided type alias is infact a type alias,
|
||||
* otherwise it performs an identity transformation
|
||||
* and returns the "alias" untouched.
|
||||
*
|
||||
* Params:
|
||||
* typeAlias = the potential type alias
|
||||
* Returns: the concrete type, or `typeAlias` if
|
||||
* not an alias
|
||||
*/
|
||||
private string getConcreteType(string typeAlias)
|
||||
{
|
||||
/* Check if this is a system type alias? If so, transform */
|
||||
if(isSystemType(typeAlias))
|
||||
{
|
||||
return getSystemType(typeAlias);
|
||||
}
|
||||
// TODO: Add user-defined type alias support here
|
||||
/* Else, return the "alias" untouched */
|
||||
else
|
||||
{
|
||||
return typeAlias;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the given type is a type alias.
|
||||
*
|
||||
* Params:
|
||||
* typeAlias = the type to check
|
||||
* Returns: `true` if it is an alias, `false` otherwise
|
||||
*/
|
||||
private bool isTypeAlias(string typeAlias)
|
||||
{
|
||||
/* If this a system type alias? */
|
||||
if(isSystemType(typeAlias))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
// TODO: Support for user-defined type aliases
|
||||
/* Otherwise, not a type alias */
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the given type is a system type alias
|
||||
*
|
||||
* Params:
|
||||
* typeAlias = the type to check
|
||||
* Returns: `true` if system type alias, `false` otherwise
|
||||
*/
|
||||
private bool isSystemType(string typeAlias)
|
||||
{
|
||||
/* `size_t`/`ssize_t` system type aliases */
|
||||
if(typeAlias == "size_t" || typeAlias == "ssize_t")
|
||||
{
|
||||
return true;
|
||||
}
|
||||
/* Else, not a system type alias */
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Given a type alias (think `size_t`/`ssize_t` for example) this will
|
||||
* look up in the compiler's configuration what that size should be
|
||||
* resolved to
|
||||
*
|
||||
* Params:
|
||||
* typeAlias = the system type alias to lookup
|
||||
* Returns: the concrete type
|
||||
*/
|
||||
private string getSystemType(string typeAlias)
|
||||
{
|
||||
/* Determine machine's width */
|
||||
ulong maxWidth = compilerConfig.getConfig("types:max_width").getNumber();
|
||||
|
||||
string maxType;
|
||||
|
||||
if(maxWidth == 1)
|
||||
{
|
||||
if(typeAlias == "size_t")
|
||||
{
|
||||
return "ubyte";
|
||||
}
|
||||
else if(typeAlias == "ssize_t")
|
||||
{
|
||||
return "byte";
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
else if(maxWidth == 2)
|
||||
{
|
||||
if(typeAlias == "size_t")
|
||||
{
|
||||
return "ushort";
|
||||
}
|
||||
else if(typeAlias == "ssize_t")
|
||||
{
|
||||
return "short";
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
else if(maxWidth == 4)
|
||||
{
|
||||
if(typeAlias == "size_t")
|
||||
{
|
||||
return "uint";
|
||||
}
|
||||
else if(typeAlias == "ssize_t")
|
||||
{
|
||||
return "int";
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
else if(maxWidth == 8)
|
||||
{
|
||||
if(typeAlias == "size_t")
|
||||
{
|
||||
return "ulong";
|
||||
}
|
||||
else if(typeAlias == "ssize_t")
|
||||
{
|
||||
return "long";
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,6 @@
|
||||
module simple_meta_replace;
|
||||
|
||||
void function()
|
||||
{
|
||||
discard repr;
|
||||
}
|
||||
@ -0,0 +1,7 @@
|
||||
module meta_sizeof;
|
||||
|
||||
size_t myVar1 = sizeof(uint);
|
||||
size_t myVar2 = sizeof(ubyte);
|
||||
size_t myVar3 = sizeof(ushort)+1;
|
||||
|
||||
myVar3 = sizeof(ulong)+sizeof(size_t);
|
||||
@ -0,0 +1,3 @@
|
||||
module simple_template_type_def;
|
||||
|
||||
generic T;
|
||||
@ -0,0 +1,8 @@
|
||||
module meta_types;
|
||||
|
||||
size_t myVar = 1;
|
||||
|
||||
size_t function(size_t param1)
|
||||
{
|
||||
return 1UL+myVar;
|
||||
}
|
||||
@ -0,0 +1,12 @@
|
||||
module simple_return_bad;
|
||||
|
||||
int myFunction()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
int myFunction2()
|
||||
{
|
||||
return 2;
|
||||
int j = 1;
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
module simple_return_expressionless;
|
||||
|
||||
void expressionless()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int expressionful()
|
||||
{
|
||||
return 2;
|
||||
}
|
||||
@ -0,0 +1,12 @@
|
||||
module simple_return_good;
|
||||
|
||||
int myFunction()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
int myFunction2()
|
||||
{
|
||||
int j = 1;
|
||||
return 2;
|
||||
}
|
||||
@ -0,0 +1,6 @@
|
||||
module simple_return_type;
|
||||
|
||||
byte expressionful()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
@ -0,0 +1,13 @@
|
||||
module simple_direct_func_call;
|
||||
|
||||
int myVar = 0;
|
||||
|
||||
void otherFunction(int i)
|
||||
{
|
||||
myVar = i;
|
||||
}
|
||||
|
||||
void function()
|
||||
{
|
||||
otherFunction(69);
|
||||
}
|
||||
@ -0,0 +1,13 @@
|
||||
module simple_function_recursion_factorial;
|
||||
|
||||
ubyte factorial(ubyte i)
|
||||
{
|
||||
if(i == 0)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return i*factorial(i-1);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,6 @@
|
||||
module simple_function_return_type_check_bad;
|
||||
|
||||
ubyte factorial(ubyte i)
|
||||
{
|
||||
return 256;
|
||||
}
|
||||
@ -0,0 +1,6 @@
|
||||
module simple_function_return_type_check_good;
|
||||
|
||||
ubyte factorial(ubyte i)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
@ -0,0 +1,7 @@
|
||||
module simple_coerce_literal_bad;
|
||||
|
||||
void function()
|
||||
{
|
||||
long i1 = 1;
|
||||
byte i = i1;
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
module simple_coerce_literal_bad_stdalone_ass;
|
||||
|
||||
void function()
|
||||
{
|
||||
long i1 = 1;
|
||||
byte i;
|
||||
|
||||
i = i1;
|
||||
}
|
||||
@ -0,0 +1,7 @@
|
||||
module simple_coerce_literal_good;
|
||||
|
||||
void function()
|
||||
{
|
||||
byte i = 1UL;
|
||||
long i1 = i;
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
module simple_coerce_literal_good_stdalone_ass;
|
||||
|
||||
void function()
|
||||
{
|
||||
byte i = 1UL;
|
||||
long i1;
|
||||
|
||||
i1 = i;
|
||||
}
|
||||
Loading…
Reference in New Issue