- Fixed the parsing of bodies of structs and classes. Previously they would call `parseName()` when hitting a `SymbolType.IDENT_NAME` however this would allow assignments and function calls, we don't want this. Switched to `parseTypedDeclaration()` + checking the symbol left in lexer after it (ensuring it was a semicolon) and then consuming it)
* IPoolManager
- Added new interface
* Pool
- Added missing imports
* IPoolManager
- Moved to the `interfaces` module
* IPoolManager
- Updated API to take in a `DNodeGenerator` as the first argument to `pool(..., ...)`
* Revert "IPoolManager"
This reverts commit 4f92a29da2.
* PoolManager
- Added an implementation of the `IPoolManager` interface
* DNodeGenerator
- Now constructs a new `IPoolManager` on constructions
* IPoolManager
- Added a templatised variant of the `pool(Statement)` method
* PoolManager
- Added a templatised variant of the `pool(Statement)` method
- The `pool(Statement)` method now uses the `poolT!(DNodeType, EntityType)(EntityType)` method
* IPoolManager
- Removed the templatised `poolT!(DNodeType, EntityType)(EntityType)` method
- Added `poolExpression(Expression expression)`
- Added `poolVariable(Variable variable)`
- Added `poolStaticVariable(Variable variable)`
- Added `poolFuncDec(Function func)`
* IPoolManager
- Removed uneeded import
* PoolManager
- Removed the templatised `poolT!(DNodeType, EntityType)(EntityType)` method
- Implemented `poolExpression(Expression expression)`
- Implemented `poolVariable(Variable variable)`
- Implemented `poolStaticVariable(Variable variable)`
- Implemented `poolFuncDec(Function func)`
* ExpressionDNode
- No longer takes in a `DNodeGenerator`
AccessDNode
- No longer takes in a `DNodeGenerator`
- Save the incoming `Entity`
- Updated `initName()` to use the `toString()` of the `Entity`
ClassVirtualInit
- No longer takes in a `DNodeGenerator`
- Save the incoming `Clazz`
- Updated `initName()` to use the `toString()` of the `Clazz`
ClassStaticNode
- No longer takes in a `DNodeGenerator`
- Save the incoming `Clazz`
- Updated `initName()` to use the `toString()` of the `Clazz`
ObjectInitializationNode
- No longer takes in a `DNodeGenerator`
VariableNode
- No longer takes in a `DNodeGenerator`
- Updated `initName()` to use the `toString()` of the `Variable`
FuncDecNode
- No longer takes in a `DNodeGenerator`
- Updated `initName()` to use the `toString()` of the `Function`
ModuleVariableDeclaration
- No longer takes in a `DNodeGenerator`
- Updated `initName()` to use the `toString()` of the `Variable`
StaticVariableDeclaration
- No longer takes in a `DNodeGenerator`
- Updated `initName()` to use the `toString()` of the `Variable`
VariableAssignmentNode
- No longer takes in a `DNodeGenerator`
- Updated `initName()` to use the `toString()` of the `VariableAssignment`
* PoolManager
- No longer takes in a `DNodeGenerator` for its constructor
- We no longer require it
- No longer pass a `DNodeGenerator` to the `DNodeType(...)`s created in `poolT!(...)(...)`
PoolManager (unittests)
- Updated unittests
* Depencency (module)
- The `addFunctionDef(...)` method now takes in an extra first argument which is the `IPoolManager` it
should use when it constructs its `DFunctionInnerGenerator`
DNode
- Removed the `DNodeGenerator` instance (i.e. the `dnodegen` field)
- Removed the `Resolver` instance (i.e. the `resolver` field)
- Calling `pool(Statement entity)` will now forward that call to the `IPoolManager`'s `pool(Statement)`
- Calling `DNodeType poolT(DNodeType, EntityType)(EntityType entity)` will now forward that call to the `IPoolManager`'s `pool(Statement)` with the correct types decided at compile-time using static if's
- `objectInitialize(Clazz clazz, NewExpression newExpression)` now constructs a `ObjectInitializationNode` with
its new API
- `pool_module_vardec(Variable entity)` now constructs a `ModuleVariableDeclaration` with its new API
- When `generalStatement(Container c, Context context, Statement entity)` comes across a function definition
(i.e. a `Function`) and has to add its function definition it now uses the updated `addFunctionDef(...)`
- `poolClassStatic(Clazz clazz)` now constructs a `ClassStaticNode` with its new API
DFunctionInnerGenerator
- Constructor now accepts an `IPoolManager` instance
DNodeGenerator
- Constructor now accepts an `IPoolManager` instance
- We now use the `IPoolManager` as our pooling mechanism
* TypeChecker
- When we call `dependencyCheck()` we now first construct the pooling mechanism we want to use
by constructing some kind-of `IPoolManager`, we then pass this to the constructor for the
`DNodeGenerator`
* IPoolManager
- Added `poolModuleVariableDeclaration(Variable variable)`
* PoolManager
- Impemented `poolModuleVariableDeclaration(Variable variable)`
* DNodeGenerator
- `pool_module_vardec(Variable entity)` now calls `poolModuleVariableDeclaration(Variable)` from `IPoolManager`
- Removed the static `nodePool`
* IPoolManager
- Added some stuff
* IPoolManager
- Nah, removed that
* IPoolManager
- Added `poolClassStatic(Clazz clazz)`
* PoolManager
- Implemented `poolClassStatic(Clazz clazz)`
* DNodeGenerator
- Calling `poolClassStatic(Clazz clazz)` now calls `IPoolManager`'s `poolClassStatic(Clazz)`
* IPoolManager
- Documented module
* PoolManager
- Documented module
* Merge branch 'vardec_varass_dependency' into feature/poolmngr
* IFuncDefStore
- Added new interface
* FuncDefStore
- Implemented new `IFuncDefStore` type
* FuncDefStore
- The constructor now takes in a `TypeChecker` instance
- Implemented `addFunctionDef(Function func)`
* FuncDefStore
- Added a TODO + some code for a future naming setup I want to se
* IPoolManager
- Added documentation
- Added new method `grabFunctionDef(string name)` to the API
* FuncDefStoreException
- Added new exception type
* IPoolManager
- Added more docs for `grabFunctionDef(string name)`
* FuncDefStore
- Pass in ourselves (a `IFuncDefStore`) into the `DFunctionInnerGenerator` when adding a function definition
- Implemented `grabFunctionDef(string name)` from the updated `IFuncDefStore` API
* DNodeGenerator
- Constructor now takes in a `IFuncDefStore`
- When we encounter a `Function` we will add it to the store of function definitions
by using the new `IFuncDefStore` (instead of the old `addFunctionDef(TypeChecker, Function)`
- Removed unused method `saveFunctionDefinitionNode(DNode funcDefNode)`
- Removed unused method `retrieveFunctionDefinitionNode(string functionAbsolutePath)`
- Removed the old method `addFunctionDef(TypeChecker tc, Function func)` (as we are now using the `IFuncDefStore`)
- Removed the `clearFuncDefs()` as we are now using the `IFuncDefStore`
- Removed the `grabFunctionDefs()` as we are now using the `IFuncDefStore`
- Removed the `FunctionData[string]` as we are now using the `IFuncDefStore`
DFunctionInnerGenerator
- Constructor now takes in a `IFuncDefStore`
* TypeChecker
- `dependencyCheck()` no lomger calls the removed `clearFuncDefs()` from the `dependency.core` module
- `dependencyCheck()` now constructs a new `IFuncDefStore` and then passes it into the `DNodeGenerator`
when dependency generation needs to occur
* IFuncDefStore
- Added module-level documentation
* FuncDefStore
- Documented class
- Documented module
* FuncDefStoreException
- Documented constructor and class
* IFuncDefStore
- `addFunctionDef(Function func)` may now throw a `FuncDefStoreException` when you add a function that already exists
* FuncDefStore
- `addFunctionDef(Function func)` now throws a `FuncDefStoreException` when you provide a `Function` that has already been added
* IFuncDefStore
- Moved import to the top
* FuncDefStore
- Cleaned up
* Created brsnch
* Created brsnch (removed placeholder)
* Lexer
- Added tab handling for the presence such as spaces would be in.
- Added unit tests for the new tab processing
- Resolved issues where whitepsace was allowed before and or after the
'.' character
- Renamed isSpliter to isSplitter
- Some Code styling
* Check
- Added two new `SymbolType`s for comments
- `SINGLE_LINE_COMMENT` (for `//`) and `MULTI_LINE_COMMENT` (for `/*`)
* Parser
- Added a bogus `parseComment()` which returns nothing, prints out the comment, consumes the `Token` and returns
- `parseStatement()` now supports `parseComment()` whenever a single-line or multi-line comment is detected
* Parser
- Fixed token consumption code in `parseComment()`
* BasicLexer
- Fixed style mishaps
* ArrLexer
- Implemented dummy lexer
* Parser
- Added some comment related functions (for testing)
- Added `pushComment(Token)`, `hasCommentsOnStack() and `getCommentCount()`
- `parseComment()` now pushes the current comment-based `Token` onto the comment-stack
- Added a comment stack
Unit tests
- Added testing for various examples of comment-type `Token`s
* Lexer
- Replaced the characters with Enumerated type
- Working Comment lexing, single and multiline
- Working escape codes for strings
- Working Signage and Size Encoder indicators
- Removed floatMode in favour of float lexing function
- Added doComment for the comment lexing instead of comment mode
- Added doEscapeCode for escape codes in string
Testing
- Added unit tests for comments
- Added unit tests numerical encoders
- Added unit tests numerical encoders
TODO
- ADD unit tests for all valid escape sequences and some invalid
* Lexer
- Removed stringMode in favour of soString
TODO
- Decide on miltiline strings, currently not supported
* Parser
- Test comments which appear at a non-Module but rather statement lavel
* Parser
- Changed to using `BasicLexer` for comment tests now seeing as it is now implemented therein
* Basic
- Added `roll()` and `shourt()` to mark unittests
* Basic
- `shout()` now adds line number to print out
* Lexer rewrite
- flush
- underscores in numbers
- escape codes
- character escapes
- bug fixes
* Basic
- Fixed `shourt(int)`
* Basic
- Remved crashing (on purpose_ unittest
* Resolved bug where isSplitter evaluated to true every time
* Basic
- Removed `goggaWithLineInfo(...)`
* Basic
- Updated `shout()` to remove rolling
- Removed `roll()`
- Added function and module name as well
* Basic
- Documented `shout()`
* Lexer Done and 100% coverage
* LexerSymbols
- Documented
- Formatted
* Lexer (module)
- Added `LS` alias
- Added `isOperator(char c)`, `isSplitter(char c)`, `isNumericalEncoder_Size(char character)`, `isNumericalEncoder_Signage(char character)` and `isValidEscape_String(char character)`
* BasicLexer
- Documented constructor `hasToken()`, `performLex()`, `doIdentOrPath()`, `doChar()`, `doString()`, `doComment()`, `doEscapeCode()`, `doNumber()`, `doEncoder()`, `doFloat()`, `flush()`, `buildAdvance()`, `improvedAdvance()`, `advanceLine()`, `isOperator(char)`, `isSplitter(char)`, `isValidDotPrecede(char character)`, `isNumericalEncoder(char character)`, `isNumericalEncoder_Size(char character)`, `isNumericalEncoder_Signage(char character)` and `isValidEscape_String(char character)`
- Tried reformatting some of `doChar()`, `doString()`, `flush()`, `buildAdvance()`, `improvedAdvance()`, `advanceLine()`, `isOperator(char)`, `isSplitter(char)`
* Basic
- Removed `LS` alias
Lexer
- Made `LS` alias public
* BasicLexer
- Removed methods `isValidEscape_String(char character)`, `isNumericalEncoder_Signage(char character)`, `isNumericalEncoder_Size(char character)`, `isNumericalEncoder(char character)`, `isSplitter(char c)` and ` isOperator(char c)`
Lexer
- Added method `isNumericalEncoder(char character)`
* BasicLexer
- Documented `isValidDotPrecede(char character)`
* Lexer
- Added method `isValidDotPrecede(char character)`
* BasicLexer
- Removed method `isValidDotPrecede(char character)`
* BasicLexer (unittests)
- Documented the unittests
- Fixed formatting
* BasicLexer
- Typo fixes
* BasicLexer (unittests)
- Only compile-in `shourt(...)` when in unittest build mode
* BasicLexer
- Documented `isForward()` and `isBackward()`
- Made `isBackward()` private
---------
Co-authored-by: GMeyer <21568499@sun.ac.za>
Co-authored-by: GMeyer <gustav.meyer1999@gmail.com>
- Added commands to `TypeCheckerBase!()` mixin template
- Added `TypeCheckerInit(Compiler compiler)`
- Use the template in both `compile` command and the`typecheck` command
- Moved the reference counting mechanism into the `TypeChecker` to avoid problem of seperate `DNodeGenerator` instances having their own seperate counts
- We now check the reference count values after function definition processing so as to get a proper count
Dependency
- Use the reference counting from `TypeChecker`
- Removed reference counting code
Test cases
- Added a positive case in the form of `unused_vars.t`
- Added a negative case in the form of `unused_vars_none.t`
- When handling a standalone assignment to a variable increment it's reference count
- This was updated in the handling of `VariableAssignmentStdAlone`
- Added `varRefCounts` which maps a given `Variable` to its reference count. This includes the declaration thereof.
- Added `touch(Variable variable)` which Increments the given variable's reference count
* Compiler
- Re-enabled compilation tests (partially)
* Dependency
- Fixed comment
- Implemented `clearFuncDefs()`
* TypeChecker
- Clear the `FunctionData[string]` table after a batch of typechecking/codegen such that we don't have lingering data from previous compilations which gets reliniearzed resulting in an exception being thrown as it was marked as linearized from its first time from a previous compilation
* Compiler
- Re-enabled unit tests for compilation
- Added TODO relating to adding failing test cases as well
* Compiler
- Added unit test for failing tests
* TypeCheck
- Use a scopre guard to call `clearFuncDefs()` such that it is called even when exceptions are thrown during depgen, typecheck/codegen ensuring we have it cleared for the next run
* Compiler
- Added `gibeFileData(string)` to easily read the source text
- Added all `typecheck` (good and bad) tests
* Pipelines
- Updated name
* Compiler (unittests)
- Re-ordered the test cases
- Commented them out
* Compiler
- Added documentation for `gibFileData(string)`
- Made `gibFileData(string)` private
* Compiler (unit tests)
- Documented unit test
* Compiler
- Cleaned up imports
* Compiler (unit tests)
- Added TODO
- Added spacing
