All Classes and Interfaces
Class
Description
The abstract base on most antlr listeners.
Uses the symbol and scope management to traverse back up stack to determine if
the outer parent is a generic type or not and also if this symbol passed in is a generic type.
Just gets the left and right hand side of values in an expression.
Check that a symbol can be accessed issues error if not possible.
Support for taking one aggregate and manipulating the methods and the like to be applied
to another aggregate.
Predicate to see if an aggregate mandated pure in its construction.
This is typically a 'class' or an interface type where it can include the definitions of new
properties.
An aggregate, but one that can have zero or more traits (like interfaces).
Checks that all the text bodies that are on the super are also present in the language variant.
Search for a symbol of any category with the matching name.
Search for a symbol of any types category with the matching name.
Checks for the appropriate use of the APPLICATION of xyz on a method declaration.
Checks if the body of a method/operator is appropriate.
Checks if the body of a function is appropriate.
Readability check metric.
Used as simple one-liners to check a value and issue an illegal argument exception if empty.
Used to decouple checks from the grammar contexts.
Just really pulls up the appropriate symbol from the expression into this context.
Checks the assignments for operator : := = and :=? that's all.
Used in the full resolution phase to check assignments.
Check the assignment to a variable can be a single assignment or a deep copy type assignment.
Designed to add in methods on the aggregate where the 'traits' use is 'traits by'.
The ek9 developer does not need to redeclare incoming or returning parameters for dynamic functions.
Supplies the compiler phases for the back end.
Creates a suitable scope name for a token position.
Just resolves a number of built-in types so that internal compiler code can be more explicit.
Designed to deal with this following part of the EK9 grammar.
Just re-uses the bulk of method symbol for when we want to make a symbol that is a call
to an actual method.
Used to actually hold the captured symbols.
Just focuses on the ability to possible capture variables from an enclosing scope.
Just checks and records the appropriate type for the case expression, based on how it is used.
Deals with normal operators (i.e.
Checks that the use of the variable only if it has a web variable correlation is valid.
Checks that methods from a super and one or more traits do not conflict.
If the aggregate is a generic parameterised type this function triggers a check for duplicated methods.
Error when the definition of a service is invalid.
Error when the definition of a service operator is invalid.
Ensures that a try statement/expression is used correctly in or out of an expression.
Used for variable forms of simple code flow analysis.
Designed to be used in a transient manner when interacting with variables.
MULTI THREADED
Generate all type of aggregates, typically classes, components, records, etc.
MULTI THREADED
Generate all constants that have been defined.
MULTI THREADED
Generate all functions (including dynamic and templated) that have been defined.
MULTI THREADED
Preparation to generate code.
SINGLE THREADED
Optimise the generated code.
Just deals with handling the command line options for the compiler.
For use when looking to find common types.
Attempts to find a common type from the CommonTypeDeterminationDetails or issues errors.
Given a list of symbols (normally variables), this code will get the type from each of those symbols.
Given a symbol, this check that the type that the symbol has can support the '<=>' operator.
Represents the whole program(s) that the developer is attempting to create.
Holds a reference to the name of the file being compiled a checksum of the
file and the date time last modified.
Check to see if any of the compilable sources have errors.
A context to hold all the essential objects needed for compiling.
Populated in the compilable program and altered during each of the phases of compilation.
As and when sources are processed during each phase of the compilation.
For compiler, errors, warning and other information from the compiler.
Identifies the ordered set of compilation phases used in EK9.
Register this event listener with the compiler to pick up on
any warnings of errors during compilation.
Effectively a tuple for returning if the phase was a match for the required
compilation phase to be run to and if this phase ran ok.
Conceptual compiler.
Our wrapper for an unchecked exception.
Used to drive how the compiler operates.
Marks the specific activity of a compiler phase.
Just expends the standard reporter to use the EK9Comp message prefix.
You may think why this mapping.
Designed to encapsulate the fact that two token are in conflict for a Symbol.
Checks that either all parameters are named when making calls, or none are named at all.
A very simple type that holds a single distinct value.
Checks for the containing construct type and whether it is marked as abstract or not.
Just checks that an expression used in a control for if/while etc is a Boolean type.
EK9 switch/try control type symbol - this can effectively return a value if it is configured
with returning part.
Used for checking covariance based on a variable.
Given a symbol, this check that the type that the symbol has can support the '--' operator.
Test if a symbol is externally implemented.
Checks that operators that have been 'defaulted' could actually be implemented.
Just go through and define the symbols and scopes putting into the ParsedModule against the appropriate context.
To be used when checking if a variable Symbol is a function delegate and can accept a set of call arguments.
A Lexer, but one that delegates to the actual lexer that in plugged in.
Designed to deal with managing dependencies of ek9 modules.
Represents a single dependency by moduleName and version.
Why was a dependency rejected.
Just creates DependencyNodes by using a Source Visitor on some EK9 source that has a package
defined in it.
De-Serializes a byte array back to compilable program.
Creates/Updates an ek9 Dict (Dictionary/Map) of a specific types if the expressions are typed correctly.
Wraps the SHA 256 digest and the resulting byte array into objects,
so we can deal with check objects rather than raw bytes.
A Checksum.
Provides basic interface for the EK9 internal @ type directives.
Provides the listeners for directive checks.
Just extracts the compilation phase or throws an illegal argument exception.
Finds the next line number from where a directive has been used.
Specification of a directive, all the common details used in a range of directives.
Just extract the spec from the free format data in the directive.
Just extracts the symbol category or throws an illegal argument exception.
Just extracts the symbol name or throws an illegal argument exception.
To be used in EK9 source code, for things like internal tests
or compiler directives, instrumentation, reified type retention etc.
Resolves the variables to be captured and defines new variable symbols against the appropriate scopes.
Checks that a dynamic class does not used naming when used inside a generic type/function.
Checks if a dynamic function body is needed and provided.
Deals with handling any returning values in a dynamic function.
Dynamic Variables when captured have to either be identifiers in their own right,
but if they are some type of expression, method call, etc.
Abstract base for the command line ek9 commands.
HERE FOR
Ek9Compiler (COMPILER) ENTRY.Clean a project down.
Deploy a package / all packages inside the project directory.
Check and pull all dependencies in.
Do a full recompile of all sources inside project.
Generate signing keys.
Install a package to your own $HOME/.ek9/lib directory.
Just does an incremental build if possible.
Just increments a version number.
Main entry point into the compiler, build system and language server.
This class provides an empty implementation of
EK9Listener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
EK9Visitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.Just loads the ek9 language builtin ek9 source code and supplies it as Compilable Source.
The main EK9 compiler (HERE FOR COMPILER ENTRY).
Designed to hold the all the soft coded configurations for the
EK9 language server, these will typically be things like.
Responsibility of dealing with aspects of the ek9 directory structure.
Loads the language basics into a Compilable Program.
The Language Server Implementation into the modular EK9 compiler.
Designed for us in the LSP only as a set of words that are part of the language.
Holds information relating to the EK9 language keywords.
Original good for python but too pythonesque for EK9 -
needed reworking to remove # comment and tabs for indenting.
Just wraps up the creation of the EK9Lexer from an inputStream.
This interface defines a complete listener for a parse tree produced by
EK9Parser.Designed only to be used on the front end of the compiler to access
properties files that are in the .ek9 directory just off the same directory as the
file that the compiler was asked to compile.
Base service for EK9 language compilation.
A cut down visitor that just deals with packages at a basic level.
Part of the language server functionality.
Models a token that we need to create as a synthetic token.
Used to cache built in types as they are so frequently used.
This interface defines a complete generic visitor for a parse tree produced
by
EK9Parser.Part of the language server functionality.
Error if a construct and a reference conflict with each other.
Error when a reference is made, but it cannot be resolved.
To be called when an unreachable statement is encountered to emit an error.
Creates/Updates an enumerated type adding methods as appropriate.
Attempts to locate an Enumeration by name.
Do packaging for package / all packages inside the project directory.
Print the version number of the package.
Run the application that has been built or is already built.
To be used in EK9 source code to assert that an error will be created.
Just checks if there are any directives that relate to errors in the parsed module and tallies those up
with any errors held for the phase of compilation.
We need an error listener for the lexing parsing and also our own tree
visiting.
Fine detail of the error.
The type of the error.
The details of an error, position, etc.
What is the semantic nature of the error.
Convert ErrorListener warnings and errors to LSP Diagnostics.
Use to explicitly set a feature name on a package.
Used to explicitly set the version of a package.
Run all unit tests inside a project.
Base for the versioning commands.
The version.
Just wraps any exceptions in a runtime CompilerException.
Checks that the symbol passed has a type and that the type is compatible with an EK9 Exception.
An exception that when caught at the very outer edge of the compiler will cause the application
to exit with a specific error code.
Ensures that 'expression' is now resolved and 'typed' or a not resolved error.
This listener just deals with expressions and the types that result from expressions.
While we don't add these in the scoped structures when compiling.
Useful in expressions to contain the left and right hand symbols.
Test if a symbol is externally implemented.
Because we need access to the full file list or partial file list filtered.
Designed to abstract out all file handling for the compiler.
Deals with the for loop for phase 3, which is basically working out the type of the variable being iterated over
and ensuring that the expression is something that can be iterated over.
Pulls the type from the 'range' into the loop variable, so it is correctly typed or emits an error.
Ensures that a for loop/for range statement/expression is used correctly in or out of an expression.
Deals with checking the 'for' statement/expression.
Checks the for structure via the code analysers.
EK9 'for' type symbol - we need a scope because we declare a new variable as the loop variable.
Supplies just the front end of the compiler.
Supplies all the phases for a full compilation from end to end.
To be used when checking if a function can accept a set of call arguments.
Check is the data passed in enabled a delegate function to be resolved and if so return that Function.
Typically checks any returning values to see if they have now been initialised on a function.
Checks that the function correctly overrides the signature if it has a super.
Scope for functions that are part of a module.
Search just for a matching function by name.
Used to see if it is possible to resolve types, both simple and parametric.
Checks that a constructor method on a generic aggregate has the same number of
parameters as the types being used in the generic type.
Used to model the scenario where a generic type has another dependent generic type used within it.
To be used in EK9 source code to assert that a type can or cannot be resolved.
Just checks if there are any directives that relate to @Genus in the parsed module and checks the
resolution through the symbol and its genus.
Extracts the guard variable if there is a guard expression.
Given a 'type' (the IAggregateSymbol passed in), see it would be possible to
iterator over it with some other type.
Used for file path matching GLOB not regex.
Checks that the guard expression is valid.
Given a symbol, this check that the type that the symbol has can support the '#?' operator.
Checks the possible operation variable, literal or function for suitability for use with
'head', 'tail' and 'skip'.
Converts bytes to Hexadecimal and back.
Checks HTTP Access for service operations because some require HTTP_SOURCE, but others do not support it.
Interface for an aggregate, typically a class or something like that.
Really a Marker interface for generic classes and generic functions.
Interface for dynamic functions and classes so that dynamic variables can be captured.
Given an identifier, this consumer checks if it is a property of some aggregate.
Deals with the checking and setting initialised of the identifier.
Used for pure identifier resolution and recording.
Ensures that 'identifierReference' is now resolved and hangs together and is 'typed' or emit "not resolved" error.
Basic interface signature for the language server.
Checks the IfStatement is valid or emits errors.
Deals with checking if all paths through if/else/else-if/else result in variables meeting criteria.
Used by functions and methods as they may return a symbol (variable).
Typically used with programs.
To be used in EK9 source code to assert that a type can or cannot be resolved as extending a type or function.
Just checks if there are any directives that relate to @Implements in the parsed module and checks the
resolution through the symbol and its hierarchy.
Given a symbol, this check that the type that the symbol has can support the '++' operator.
Checks that variable only and variable declarations have symbols that have been referenced.
Given some sort of generic type a function or a type with a set of 'type parameters',
create a unique internal name for that combination.
Error when the definition of an enumerated values could be invalid.
SINGLE THREADED.
MULTI THREADED
All symbols resolve and so should be able to create an intermediate representation.
SINGLE THREADED.
Concept of a scope where functions, methods and variables can be declared.
The main type of scope in use a block is just like a set of instruction inside an if block
or a while block whereas a non-block is as the whole class/function/component level.
For symbols that are both a pure symbol but can also define a scope.
Given an aggregate and a symbol, this predicate checks if the symbol is a property/field of that aggregate.
Given a symbol, this check that the type that the symbol has can support the '?' operation.
Represents the concept of what functionality a Symbol should have.
Typically used on symbols; so we know their broad use and type.
Typically, used on aggregates because we might use a AggregateSymbol
But when coming to process it we need to ensure other aggregate symbols that extend
it are of compatible genus i.e a class can only extend a base class not a style
but one style could extend another style.
The internal model of a parse token - typically created.
Used in various ways to hold a token from the parse, so we can reference back to source code.
For when we just need to read ek9 files and pull out bits and bobs
rather than actually compiling.
Designed to hold all the global sort of settings for the language and compiler.
Due to way Antlr does is class generation we need to make an interface to decouple to
enable debugging and alternatives.
Checks the left hand side and the right hand side for assignment compatibility.
Creates/Updates an ek9 list of a specific type if the expressions are typed correctly.
Used in many ways via composition.
Extracts a string for the form "on line 6 in 'filename.ek9'".
Extracts a string for the form "on line 6 in 'filename.ek9'".
Wrapper for logging.
A bit of a catch 22, need to issue errors and the like when traversing an identifier in
some circumstances.
Returns the appropriate operator text symbol for the expression.
There are times when it is necessary to compare a range of symbols to see
which is the best match.
An initial stuff for match results.
Useful when attempting to traverse up stacks to find both the method and its parent aggregate.
Just checks that named operator methods:
mod, rem, abs, sqrt, open, close, contains, matches, empty, length
are not being used as just method names.
Typically checks any returning values to see if they have now been initialised on a method.
Check overrides on methods.
Simple record tuple to combine the scope to be searched and the method signature to be searched for.
Represents some type of method that exists on an aggregate type scope.
Quite a few option to a method search.
Create a MethodSearch symbol for an operation that could have a single expression or two expressions.
Models a set of result for a search for methods.
Supplies the middle end phases for compilation..
Defines a module scope, the main concept for namespaces in EK9.
Goes through each module name and checks each of the parsedModules in that module name to check
there is only a single copy of that symbol in the whole module name space.
This is a very special scope, because the same 'module name' can be defined in
multiple files.
Used when trying to locate the current class or dynamic class, to be able
to check if access to fields or methods should be allowed, or even resolve methods without 'this' prefix.
Checks if a symbol can be mutated, this is nothing to do with a pure context.
Given some sort of generic type a function or a type with a set of 'type parameters',
create a unique internal name for that combination.
As it is possible to have a variable that is a delegate 'function',
it means that to call that function, the ek9 developer would use variable-name(parameters).
As all properties on records are public, it is necessary to check they do not get
duplicated.
Examines all the service operations on a service and looks at the verbs used and the uti proto paths.
Just checks for duplicated trait names in the list.
Does a simple check (excluding any inheritance) for duplicated operations (methods, operators) on
any sort of Aggregate, i.e.
Typically used for Constructors, but could be used in other contexts where a method
is not expected to return anything.
Designed to check if variable name and method names collide with Type/Function names.
Aimed at methods in services and a program (which is a method).
Can be MULTI THREADED for developer source, but single threaded for bootstrapping.
Just check is a scope has normal termination.
Typically used in control expressions to check developer is not doing a while(true).
Typically used when a direct call is being bad on the symbol.
Check not dispatcher methods.
Checks that the variable supplied (if not null and has a type), does not have a type that
is a genericTypeParameter.
Used where traits are implemented 'by' a variable.
To be used in EK9 source code to assert that a type can or cannot be resolved.
Just checks if there are any directives that relate to @Resolved in the parsed module and checks the
non-resolution.
This is the second part of the method/function chaining resolution and can be recursive via objectAccess.
Processes the Object Access start, this is the start of chained method/function calls.
Used for resolving operation calls on aggregates, which can include properties that are delegates to functions.
Is the token a simple assignment, i.e.
Designed to gather aspect of operator population.
Typically checks any returning values to see if they have now been initialised on an operator.
Provides a common set of operations for checking operators.
Operating System support and generic stuff for directories and files.
Only use when code being checked prohibits use in outer generic context.
Checks for both abstract and override.
An immutable snapshot of EK9 main package directives.
Focus on the responsibility of packaging.
Once the EK9 'Edp' dependency module has determined that a packaged module now needs to be
resolved it will call upon this resolver to make sure that it is available.
SINGLE THREADED
Take the final optimised generated code and package it in to some type of release vessel.
SINGLE THREADED
Complete any post-processing required.
Create a new parameterised symbol from a generic type and a set of type arguments.
To be used when trying to define/resolve a parameterised type.
Does the detailed for of checking a specific possible generic symbol.
Given a parent and a dependent generic type, check that all parameters have been provided with suitable
arguments, so that the Parameterized type can be used.
This will just create a Aggregate/Function 'parameterized type' of the 'generic type' with the 'type arguments'
But note it will have not - repeat NOT have - traversed the 'generic type' and cloned over the methods and
altered all the 'T', 'K', 'V' - 'type parameters' for each of the 'type arguments'
There is a separate function (TypeSubstitution) that does that.
Used for checking parameter list types match.
Checks the number and types of the two sets of parameter list match exactly.
While we don't add these in the scoped structures when compiling.
Once we have parsed a module (source file) we need to keep track of the
results.
With EK9 it is possible to have multiple source files that are all in the same 'module'.
Used to hold just the transient data that will be used by listeners and visitors and
SymbolsAndScopes.
Creates the lexer and parser and plugs in the listners.
To be used to construct a parser, with a lexer.
Can be MULTI THREADED.
Just processes a bit of some EK9 source for a simple or generic type def, to return the context.
Abstract concept of a supplier of phases for a compilation.
Process the stream pipeline part, ensuring that it can be resolved.
SINGLE THREADED
If the developer has employed any sort of 'native' plugin, then it will have been referenced
and trusted at earlier phases.
SINGLE THREADED
No-op at this stage.
For Constrained Types, focus on checking it is possible to constrain the type and if so then
clones the appropriate methods/operators over and alters the types as appropriate.
Used as a base for a range of constructs that can be expressions.
Added as a common symbol type for both Functions and Aggregates that could possibly be
generic in nature and also be a parameterised type.
Just uses the name of a method in the search, to get a list of all possible method name.
SINGLE THREADED
Once full resolution has completed, additional checks need to be made.
Checks that the pre-flow expressions are valid.
At this point all templates should be present and all symbols resolved.
Designed to do additional logic checks once everything has been resolved.
Ensures that 'primary' is now resolved and 'typed' or a not resolved error.
Processes and checks Methods that apply in all method contexts for basic correctness.
Deals with handling any returning values in a dynamic function.
Checks on a guard expression and marks the identifier variable as initialised.
Checks in the context to see if a returning variableDeclaration or a body is defined.
Designed to enable a developer to wrap lots of different type of
processing and expose any exceptions.
Constructs like methods and functions may or may not always retun a value.
Check trait specifics on constructors/methods/operators, Allowing missing body but marking as abstract.
Checks for inferred declarations of variables in various contexts.
Checks on whether the '?' can be used as a modifier
then check the parent of this context.
Deals with checking the 'while' or 'do/while control variable in the statement/expression.
Check if this type being supplied to the test can be used as a program argument.
A program can only accept specific types of arguments to it.
A program can only return an Integer (exit code).
If all has gone well in previous phases, this just adds the IR to the main program(s).
Used for resolving and recoding of fields on specific types.
For doing pure checks on method and functions.
Checks if the pure modifier has been used correctly on methods and functions.
Just check that with in the current 'context' - if pure that the processing call is pure.
Checks the Range and ensures that there a Symbol recorded against that context.
SINGLE THREADED - because we only want one reference shorthand for an item.
Antlr listener for the references phase.
Rather than just check if the actual ISymbols are the same, this code checks if two
symbols actually refer to the same source token from the same source file.
Designed to ensure consistent reporting as part of the command line
commands and executions.
To be used with operators on aggregates (except for the is-set ? operator, that has to deal with functions).
To be used in EK9 source code to assert that a type can or cannot be resolved.
For resolved directives.
Used where traits are implemented 'by' a variable.
To be used in EK9 source code to assert that a type can or cannot be resolved.
Just checks if there are any directives that relate to @Resolved in the parsed module and checks the
resolution.
A bit of a long-winded name, but this is really the second pass of the second phase of compilation.
This is a really critical point, because this attempts to ensure that ANY expression
results in a symbol that has been 'typed'.
Mainly used in the CompilableProgram for resolving or defining a new Parameterized type.
Used for resolving a function (by just name) or a variable that is a function delegate.
Check for valid function parameters.
Locate a possible call to an identifierReference, so some sort of call.
Given a search for a method from an aggregate - and include supers/traits etc,
this function will try and locate the method.
The bulk of the processing is in the abstract base.
The bulk of the processing is in the abstract base.
The bulk of the processing is in the abstract base.
This is a sort of hybrid resolver or definer function.
Used as an abstract base for parameterised types.
Accesses the aggregate and gets just the 'default' operators defined on that aggregate (not any hierarchy).
get the appropriate return type from functions, methods and function delegates and constructors.
Designed to be extended by rules and checkers.
Represents a symbol that also has a scope.
This stack object is only designed to be used when first parsing.
Just focussed on ensuring that scopes are correct push on to the scope stack.
Can be a normal version number like 6.8.2-9 i.e 9 is the build number
Or can be for a feature like 6.1.6-specialFeature12-19 i.e.
Serializes a compilable program to a byte array, so it can be saved/reused as required.
EK9 LSP server launcher.
Typically checks any returning values to see if they have now been initialised on a service operation.
Scope for callable methods (operations) that are part of a Service.
Checks the use of registering a service is valid and then ensures that the 'Application'
is altered from being a general application to a service application.
Looks at the returning param (if not null) and sets the symbol type as appropriate.
The Generic T used in parametric types will exist but won't have any methods on yet.
Concept here is to be able to protect raw java objects from multiple threaded access.
Just a wrapper around java public private key processing.
Defines the concept of an EK9 source file.
Used when duplicate symbols are found, where we need to add a placeholder.
Validates that the statement is OK and emits errors if this is not the case.
Used in Stream assembly processing to check aggregate use validity.
The construct for a Stream statement/expression.
Processes/updates and checks that a stream assembly is actually viable in terms of types.
Just re-uses the bulk of method symbol.
Deals with working out what the type being 'catted' is.
Now does the check/processing of the whole stream pipeline.
Process and ensure that the stream termination can function correctly.
Deals with working out what the type being "for'd" is.
Checks that the arguments in the function are compatible with the current pipeline type.
Used in Stream assembly processing to check function validity.
Intended to model the pipeline flow in a streaming of cat or for loop though | and map etc.
Now does the check/processing of the whole stream pipeline.
Process and ensure that the stream termination can function correctly.
Checks for a type is resolved and is suitable genus and category.
Checks for a type is resolved and is suitable to be extended from (in basic terms).
Only types of a specific genus can be used as constraints on the generic type 'T'.
Ensures that a switch is used correctly in or out of an expression.
Deals with checking if the switch can be used as an expression and whether
the variable being switched on has the appropriate operators to meet the case criteria.
Deals with checking if all paths through switch/case/default (return) result in variables meeting criteria.
EK9 switch statement - this can effectively return a value if it is configured with returning
part.
A bit of a beast.
Models information used in code analysis for variable variable states.
Used when checking access to fields/properties and methods.
General utility class that searches in a scope for a symbol to check for duplicates.
Can be MULTI THREADED for developer source, but must be single threaded for bootstrapping.
Just a factory for all types of EK9 symbol.
Returns the appropriate symbol from the symbol and scope management component.
Given some search criteria and a List of Symbols, this class will find the best match.
Checks if a symbol has been referenced or not (can be null - no error).
MULTI THREADED
Now try and check that all symbols used have a type.
Used as external helper to record symbols and scopes across the parser.
To be used to search for symbols in a Symbol table.
Can be used for a single Simple named search.
Just extracts the ISymbols from the expression contexts and issues not resolved errors if any are not present.
We need to support simple things like classes which are unique per symbol table
Or the fully qualified class names like 'com.some.A and com.other.A' so they won't collide.
Given a list of arguments (ISymbols), go through and extract the types out.
Provides the PossibleGenericSymbol type of the symbol if it has been typed, or empty.
Looks at the function and if it has no super function, attempts to work out what would be the
best super function generic type it could implement.
Some aggregates like classes, components, etc.
A Search for a TEMPLATE of a FUNCTION.
SINGLE THREADED
Now just create all the nodes that are generated from generic types
So these will be the set of concrete template classes we are using throughout the program all
modules!
TODO need to think about where the concrete templates should be recorded.
A Search for a TEMPLATE of a TYPE like a CLASS.
Extract the valid language value from the String literal or null and error.
Check an assignment again 'super' use and some operators against 'this' use.
Just focus on resolving 'this' or 'super' in respect to a 'call'.
Checks and assigns type a 'this' or 'super' symbol, but only if it valid.
Checks that the throw statement actually throws and Exception type.
Converts a list of symbol using their friendly names in to a comma separated list.
Listen as Tokens are consumed as they are pulled from the Lexer into the parser.
Typically used for locating the nearest token to some position in a source code file.
But also to aid in listing out tokens so that when building grammars out of tokens
it is possible to see what is being produced.
Check trait specifics on methods/operators.
Gets the abstract methods and then resolves each to see what the resulting method would be.
Ensures that a try statement/expression is used correctly in or out of an expression.
Deals with checking the try statement/expression.
Checks the try/catch/finally structure via the code analysers.
EK9 try statement - this can effectively return a value if it is configured with returning part.
Given a Symbol that is some form of type, check that it could receive some piped data.
Holds the coercions we can make from and to on types.
TO be used when checking the left hand side and the right hand side with specific operators.
Checks that any recursive type constraints on a type are valid.
Checks the covariance compatibility of two variables, this will traverse them to get their types.
Pass a string of an ek9 typeDef in and use the
EK9 parser to just handle the breaking up of a String of a TypeDef into
a structure and names.
Designed to be used in phase3 only on or after - FULL_RESOLUTION.
SINGLE THREADED - Run across sources to check for types, functions and traits for 'super loops'.
Checks that the symbols in list one and list two are each the same for the corresponding position in the list.o
Check that the types of two symbol ar compatible with each other.
Accepts an aggregate or a function that has been parameterized with 'type arguments'.
A Search for a concrete actual TYPE like a RECORD or a CLASS for example.
Used to check if variables within code blocks when declared without being initialised, actually
get initialised before they are used.
Checks if a variable should be processed as a possible uninitialised variable.
Unique ID generator.
Checks to see if a property on an aggregate is safe to access.
Update/Upgrade the Ek9 compiler itself.
Checks if a function extends another function and if it is abstract.
Checks methods from various contexts, typically this is delegated to other functions.
Checks operators from various contexts, typically this is delegated to other functions.
Error when use of ParameterisedType has additional expression parameters in wrong context.
Checks the PATH value (if this is a path parameter) and ensures that the name appears in the path itself
on the operation.
Checks that if a return is used (i.e.
Check that a service operation complies with ek9 rules or return types etc.
Error when a reference is attempted by the syntax is incorrect.
Checks on the assignment during a declaration and emits an error if not valid.
Checks that variable declarations is acceptable.
Focus on checking a variable only declaration, now that types are all known.
Accepts a variable only declaration and ensures the variable is recorded if appropriate, for transient flow checks.
Models a variable.
Does a simple check (excluding any inheritance) for visibility rules on methods/operators on
aggregates.
When searching for methods, this will be a weighted result of how well a method matched.
Ensures that a while do/while statement/expression is used correctly in or out of an expression.
Deals with checking the 'while' or 'do/while statement/expression.
Checks the while statement via the code analysers.
EK9 'while' or 'do/while' type symbol - we need a scope because we can declare new variables as part of the
pre-flow semantics.
Designed to represent one or more source files that are part of a workspace.
Very simple wrapper for binary contents.
Just a common base directory and a list of files with that common base.