Namespace: compiler

Classes

Interfaces

Type Aliases

Variables

Functions

Type Aliases

ASTArithmeticExpressionKind

Ƭ ASTArithmeticExpressionKind: typeof RULE_additiveExpression | typeof RULE_multiplicativeExpression

Union type of all possible kind values for a constructable ArithmeticExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/arithmetic-expression/arithmetic-expression.ts:17

ASTBitwiseExpressionKind

Ƭ ASTBitwiseExpressionKind: typeof RULE_bitwiseAndExpression | typeof RULE_bitwiseOrExpression | typeof RULE_bitwiseXorExpression | typeof RULE_bitwiseShiftExpression

Union type of all possible kind values for a constructable BitwiseExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/bitwise-expression/bitwise-expression.ts:15

ASTClassMemberDeclarationKind

Ƭ ASTClassMemberDeclarationKind: typeof RULE_classPropertyDeclaration | typeof RULE_classMethodDeclaration | typeof RULE_classConstructorDeclaration

Defined in

kipper/core/src/compiler/ast/nodes/declarations/type-declaration/class-declaration/class-member-declaration/class-member-declaration.ts:8

ASTComparativeExpressionKind

Ƭ ASTComparativeExpressionKind: typeof RULE_equalityExpression | typeof RULE_relationalExpression

Union type of all possible kind values for a constructable ComparativeExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/comparative-expression/comparative-expression.ts:16

ASTDeclarationKind

Union type of all possible kind values that have a constructable Declaration AST node.

Note that not all ParseRuleKindMapping rule context classes have a corresponding AST node class. For example, the ParseRuleKindMapping.declaration rule context has no corresponding AST node class because it is a union of all possible declaration types.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:146

ASTDeclarationRuleName

Union type of all possible ruleName values that have a constructable Declaration AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:233

ASTExpressionKind

Union type of all possible kind values that have a constructable Expression AST node.

Note that not all ParseRuleKindMapping rule context classes have a corresponding AST node class. For example, the ParseRuleKindMapping.primaryExpression rule context has no corresponding AST node class because it is a union of all possible primary expression types.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:181

ASTExpressionRuleName

Union type of all possible ruleName values that have a constructable Expression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:266

ASTInterfaceMemberDeclarationKind

Ƭ ASTInterfaceMemberDeclarationKind: typeof RULE_interfacePropertyDeclaration | typeof RULE_interfaceMethodDeclaration

Union type of all possible kind values for a constructable InterfaceMemberDeclaration AST node.

Since

0.12.0

Defined in

kipper/core/src/compiler/ast/nodes/declarations/type-declaration/interface-declaration/interface-member-declaration/interface-member-declaration.ts:11

ASTKind

Ƭ ASTKind: typeof ParseRuleKindMapping[keyof typeof ParseRuleKindMapping]

Union type of every possible AST kind number mapped to a KipperParser rule.

Not every number contained here is mapped to a constructable AST node. Some may be only used for internal purposes inside the parser. For completion’s sake, all numbers are listed here regardless.

Since

0.10.0

Defined in

kipper/core/src/compiler/lexer-parser/parse-rule-kind-mapping.ts:128

ASTLogicalExpressionKind

Ƭ ASTLogicalExpressionKind: typeof RULE_logicalAndExpression | typeof RULE_logicalOrExpression

Union type of all possible kind values for a constructable LogicalExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/logical-expression/logical-expression.ts:17

ASTNodeParserContext

Ƭ ASTNodeParserContext: ParserExpressionContext | ParserStatementContext | ParserDeclarationContext

Union type of all rule context classes implemented by the ParseRuleKindMapping that have a corresponding AST node class.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:136

ASTPostfixExpressionKind

Ƭ ASTPostfixExpressionKind: typeof RULE_incrementOrDecrementPostfixExpression | typeof RULE_typeofExpression

Union type of all possible kind values for a constructable PostfixExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/postfix-expression/postfix-expression.ts:17

ASTPrimaryExpressionKind

Union type of all possible kind values for a constructable PrimaryExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/primary-expression/primary-expression.ts:17

ASTStatementKind

Union type of all possible kind values for a Statement AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:162

ASTStatementRuleName

Union type of all possible ruleName values that have a constructable Statement AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:250

ASTTypeDeclarationKind

Ƭ ASTTypeDeclarationKind: ASTInterfaceMemberDeclarationKind | ASTClassMemberDeclarationKind | typeof RULE_interfaceDeclaration | typeof RULE_classDeclaration

Union type of all possible kind values for a constructable TypeDeclaration AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/declarations/type-declaration/type-declaration.ts:13

ASTTypeSpecifierExpressionKind

Ƭ ASTTypeSpecifierExpressionKind: typeof RULE_identifierTypeSpecifierExpression | typeof RULE_genericTypeSpecifierExpression | typeof RULE_typeofTypeSpecifierExpression

Union type of all possible kind values for a constructable TypeSpecifierExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/type-specifier-expression/type-specifier-expression.ts:16

ASTUnaryExpressionKind

Ƭ ASTUnaryExpressionKind: typeof RULE_incrementOrDecrementUnaryExpression | typeof RULE_operatorModifiedUnaryExpression

Union type of all possible kind values for a constructable UnaryExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/unary-expression/unary-expression.ts:17

AnalysableNodeChild

Ƭ AnalysableNodeChild: AnalysableASTNode

An eligible parent for an analysable AST node.

Defined in

kipper/core/src/compiler/ast/analysable-ast-node.ts:27

AnalysableNodeParent

Ƭ AnalysableNodeParent: AnalysableASTNode | RootASTNode

An eligible parent for an analysable AST node.

Defined in

kipper/core/src/compiler/ast/analysable-ast-node.ts:22

BuiltInTypeArrayGenericArguments

Ƭ BuiltInTypeArrayGenericArguments: [{ identifier: "T" ; type: ProcessedType }]

Represents the generic arguments for the built-in type Array.

Since

0.12.0

Defined in

kipper/core/src/compiler/semantics/types/built-in/array.ts:17

BuiltInTypeFuncGenericArguments

Ƭ BuiltInTypeFuncGenericArguments: [{ identifier: "T" ; type: ProcessedType[] }, { identifier: "R" ; type: ProcessedType }]

Represents the generic arguments for the built-in type Func.

Since

0.12.0

Defined in

kipper/core/src/compiler/semantics/types/built-in/func.ts:18

CompilableNodeChild

Ƭ CompilableNodeChild: CompilableASTNode

An eligible child for a compilable AST node.

Since

0.8.0

Defined in

kipper/core/src/compiler/ast/compilable-ast-node.ts:31

CompilableNodeParent

Ƭ CompilableNodeParent: CompilableASTNode | RootASTNode

An eligible parent for a compilable AST node.

Since

0.8.0

Defined in

kipper/core/src/compiler/ast/compilable-ast-node.ts:25

ConstructableASTDeclaration

Ƭ ConstructableASTDeclaration: InstanceType<ConstructableASTDeclarationClass>

A union of all construable Declaration AST nodes. Uses ConstructableASTDeclarationClass to infer the type.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/declaration-ast-factory.ts:66

ConstructableASTDeclarationClass

Ƭ ConstructableASTDeclarationClass: typeof ruleMapping[ASTDeclarationKind]

A union of all construable Declaration AST node classes.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/declaration-ast-factory.ts:60

ConstructableASTExpression

Ƭ ConstructableASTExpression: InstanceType<ConstructableASTExpressionClass>

A union of all construable Expression AST nodes. Uses ConstructableASTExpressionClass to infer the type.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/expression-ast-factory.ts:66

ConstructableASTExpressionClass

Ƭ ConstructableASTExpressionClass: typeof ruleMapping[ASTExpressionKind]

A union of all construable Expression AST node classes.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/expression-ast-factory.ts:60

ConstructableASTKind

Ƭ ConstructableASTKind: ASTDeclarationKind | ASTStatementKind | ASTExpressionKind

Union type of all possible kind values that have a constructable CompilableASTNode.

This unlike ASTKind only contains the syntax kinds that have a corresponding constructable CompilableASTNode implementation and as such can be created using an ASTNodeFactory.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:226

ConstructableASTNode

Ƭ ConstructableASTNode: InstanceType<ConstructableASTNodeClass>

A union of all construable AST nodes. Uses ConstructableASTNodeClass to infer the type.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/index.ts:27

ConstructableASTNodeClass

Ƭ ConstructableASTNodeClass: ConstructableASTStatementClass | ConstructableASTExpressionClass | ConstructableASTDeclarationClass

A union of all construable AST node classes.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/index.ts:18

ConstructableASTRuleName

Ƭ ConstructableASTRuleName: ASTDeclarationRuleName | ASTStatementRuleName | ASTExpressionRuleName

Union type of all possible ruleName values that have a constructable CompilableASTNode.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:308

ConstructableASTStatement

Ƭ ConstructableASTStatement: InstanceType<ConstructableASTStatementClass>

A union of all construable Statement AST nodes. Uses ConstructableASTStatementClass to infer the type.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/statement-ast-factory.ts:64

ConstructableASTStatementClass

Ƭ ConstructableASTStatementClass: typeof ruleMapping[ASTStatementKind]

A union of all construable Statement AST node classes.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/factories/statement-ast-factory.ts:58

CustomTypeField

Ƭ CustomTypeField: ProcessedType

Represents a field of a custom type. This is simply another type.

Since

0.12.0

Defined in

kipper/core/src/compiler/semantics/types/custom-type.ts:22

CustomTypeFields

Ƭ CustomTypeFields: Map<string, CustomTypeField>

Represents a map of field names to their types.

Since

0.12.0

Defined in

kipper/core/src/compiler/semantics/types/custom-type.ts:28

CustomTypeKind

Ƭ CustomTypeKind: "interface" | "class"

Represents the kind of a custom type.

Since

0.12.0

Defined in

kipper/core/src/compiler/semantics/types/custom-type.ts:16

GenericTypeArguments

Ƭ GenericTypeArguments: { identifier: string ; type: ProcessedType | ProcessedType[] }[]

Represents the generic type arguments for a generic type.

Since

0.12.0

Defined in

kipper/core/src/compiler/semantics/types/base/generic-type.ts:7

JmpStatementType

Ƭ JmpStatementType: "continue" | "break"

Represents all possible jump statements inside Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:649

KipperAdditiveOperator

Ƭ KipperAdditiveOperator: KipperMinusOperator | KipperPlusOperator

All available additive operations inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:459

KipperAnyTypeLiteral

Ƭ KipperAnyTypeLiteral: "any"

Any type in Kipper, which can be used to represent any type.

Since

0.12.0

Defined in

kipper/core/src/compiler/const.ts:35

KipperArithmeticAssignOperator

Ƭ KipperArithmeticAssignOperator: "+=" | "-=" | "*=" | "/=" | "%="

All available arithmetic assignment operations inside Kipper.

Since

0.3.0

Defined in

kipper/core/src/compiler/const.ts:584

KipperArithmeticOperator

Ƭ KipperArithmeticOperator: KipperAdditiveOperator | KipperMultiplicativeOperator

All available arithmetic operations inside Kipper.

Since

0.3.0

Defined in

kipper/core/src/compiler/const.ts:569

KipperAssignOperator

Ƭ KipperAssignOperator: KipperEqualAssignOperator | KipperArithmeticAssignOperator

All available assignment operators inside Kipper, which can be used to assign a value to a variable/reference.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:608

KipperBitwiseAndOperator

Ƭ KipperBitwiseAndOperator: "&"

The bitwise-and operator, which can be used to combine two numbers bitwise.

Example

EXP & EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:312

KipperBitwiseNotOperator

Ƭ KipperBitwiseNotOperator: "~"

The bitwise-not operator, which can be used to negate a number bitwise.

Example

~EXP;

Since

0.11.0

Defined in

kipper/core/src/compiler/const.ts:372

KipperBitwiseOperator

Ƭ KipperBitwiseOperator: KipperBitwiseAndOperator | KipperBitwiseOrOperator | KipperBitwiseXorOperator | KipperBitwiseShiftOperator

All available bitwise operators inside Kipper, which can be used to combine two numbers bitwise.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:386

KipperBitwiseOrOperator

Ƭ KipperBitwiseOrOperator: "|"

The bitwise-or operator, which can be used to combine two numbers bitwise.

Example

EXP | EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:328

KipperBitwiseShiftOperator

Ƭ KipperBitwiseShiftOperator: "<<" | ">>" | ">>>"

All available bitwise operators inside Kipper, which can be used to combine two numbers bitwise.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:342

KipperBitwiseXorOperator

Ƭ KipperBitwiseXorOperator: "^"

The bitwise-xor operator, which can be used to combine two numbers bitwise.

Example

EXP ^ EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:356

KipperBoolTypeConstants

Ƭ KipperBoolTypeConstants: "true" | "false"

Constant names for a Kipper boolean.

Since

0.8.0

Example

var x: bool = true;

Defined in

kipper/core/src/compiler/const.ts:153

KipperBoolTypeLiteral

Ƭ KipperBoolTypeLiteral: "bool"

Boolean type in Kipper.

Since

0.5.0

Example

bool

Defined in

kipper/core/src/compiler/const.ts:145

KipperBuiltInTypeLiteral

All compilable and valid base types inside Kipper.

This is mainly different from the standard KipperType that it excludes KipperErrorType, which is only used for error handling/recovery and skips type checking altogether.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:211

KipperCallable

Ƭ KipperCallable: FunctionDeclaration | LambdaPrimaryExpression | ClassMethodDeclaration

Represents all possible callable ast nodes inside Kipper.

Since

0.12.0

Defined in

kipper/core/src/compiler/const.ts:655

KipperComparativeOperator

Ƭ KipperComparativeOperator: KipperEqualityOperator | KipperRelationalOperator

All available comparative operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:420

KipperConstructorInternalIdentifier

Ƭ KipperConstructorInternalIdentifier: typeof KipperConstructorInternalIdentifierLiteral

Represents the internal identifier for a Kipper constructor.

Since

0.12.0

Defined in

kipper/core/src/compiler/const.ts:667

KipperEqualAssignOperator

Ƭ KipperEqualAssignOperator: "="

Default assignment operator for assigning a value to a variable/reference.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:596

KipperEqualityOperator

Ƭ KipperEqualityOperator: "==" | "!="

All available equality operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:396

KipperFuncTypeLiteral

Ƭ KipperFuncTypeLiteral: "Func"

Function type in Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:83

KipperListTypeLiteral

Ƭ KipperListTypeLiteral: "Array"

List type in Kipper. KipperType T represents the type of the list content and only serves as a type checking generic type, it will not change the type itself.

Since

0.5.0

Defined in

kipper/core/src/compiler/const.ts:168

KipperLogicalAndOperator

Ƭ KipperLogicalAndOperator: "&&"

The logical-and operator, which can be used to combine multiple conditions and return true if all conditions are true.

Example

EXP && EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:266

KipperLogicalOperator

Ƭ KipperLogicalOperator: KipperLogicalAndOperator | KipperLogicalOrOperator

All available logical operators inside Kipper, which can be used to compare or combine two expressions.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:298

KipperLogicalOrOperator

Ƭ KipperLogicalOrOperator: "||"

The logical-or operator, which can be used to combine multiple conditions and return true if at least one condition is true.

Example

EXP || EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:283

KipperMetaTypeLiteral

Ƭ KipperMetaTypeLiteral: "type"

Represents the meta type in Kipper, which itself is used represents a type e.g. this is the type of a type.

Since

0.8.0

Defined in

kipper/core/src/compiler/const.ts:22

KipperMinusOperator

Ƭ KipperMinusOperator: "-"

The minus operator.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:447

KipperMultiplicativeOperator

Ƭ KipperMultiplicativeOperator: "*" | "**" | "/" | "%"

All available multiplicative operators inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:548

KipperNegateOperator

Ƭ KipperNegateOperator: "!"

Negate operator, which can be used to negate a boolean expression. It evaluates to the opposite boolean representation of the original expression.

Example

!true; // false
!false; // true
!1; // false
!0; // true

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:483

KipperNullTypeLiteral

Ƭ KipperNullTypeLiteral: "null"

Null type in Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:59

KipperNumTypeLiteral

Ƭ KipperNumTypeLiteral: "num"

Numeric type in Kipper.

Since

0.5.0

Example

num

Defined in

kipper/core/src/compiler/const.ts:113

KipperObjTypeLiteral

Ƭ KipperObjTypeLiteral: "obj"

Obj type in Kipper.

Since

0.12.0

Defined in

kipper/core/src/compiler/const.ts:47

KipperPlusOperator

Ƭ KipperPlusOperator: "+"

The plus operator.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:435

KipperPostfixOperator

Ƭ KipperPostfixOperator: "++" | "--" | "typeof"

All available increment and decrement operators, which can be used to modify the value of an expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:501

KipperPrimitiveTypeLiteral

All primitive types inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:183

KipperReferenceable

Ƭ KipperReferenceable: ScopeDeclaration

Represents a runtime variable or function that can be referenced.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:643

KipperRelationalOperator

Ƭ KipperRelationalOperator: "<" | ">" | "<=" | ">="

All available relational operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:408

KipperSignOperator

Ƭ KipperSignOperator: "+" | "-"

All available sign operators inside Kipper, which can be used to modify the value of a numeric expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:465

KipperStorageType

Ƭ KipperStorageType: "var" | "const" | "built-in"

All available storage types inside Kipper, which define how a variable is stored/can be accessed.

Defined in

kipper/core/src/compiler/const.ts:252

KipperStrTypeLiteral

Ƭ KipperStrTypeLiteral: "str"

String type in Kipper.

Since

0.5.0

Example

str

Defined in

kipper/core/src/compiler/const.ts:129

KipperUnaryModifierOperator

Ƭ KipperUnaryModifierOperator: KipperNegateOperator | KipperSignOperator | KipperBitwiseNotOperator

Modifier Unary operators, which can be used to modify the value of an expression.

This type specifically exists for the OperatorModifiedUnaryExpression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:515

KipperUnaryOperator

Ƭ KipperUnaryOperator: KipperUnaryModifierOperator | KipperPostfixOperator | KipperBitwiseNotOperator

All available unary operators in Kipper, which can be used to modify the value of an expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:533

KipperUndefinedTypeLiteral

Ƭ KipperUndefinedTypeLiteral: "undefined"

Undefined type in Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:71

KipperVoidTypeLiteral

Ƭ KipperVoidTypeLiteral: "void"

Void type in Kipper.

Since

0.5.0

Example

void

Defined in

kipper/core/src/compiler/const.ts:97

MemberAccessExpressionContext

Ƭ MemberAccessExpressionContext: DotNotationMemberAccessExpressionContext | BracketNotationMemberAccessExpressionContext | SliceNotationMemberAccessExpressionContext

A union of all possible KipperParserRuleContext rule contexts that MemberAccessExpression implements.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/member-access-expression/member-access-expression.ts:24

ParserArithmeticExpressionContext

Ƭ ParserArithmeticExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTArithmeticExpressionKind]\>

Union type of all possible ParserASTNode context classes for a constructable ArithmeticExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/arithmetic-expression/arithmetic-expression.ts:25

ParserArithmeticExpressionRuleName

Ƭ ParserArithmeticExpressionRuleName: typeof KindParseRuleMapping[ASTArithmeticExpressionKind]

Union type of all possible ruleName values for a constructable ArithmeticExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/arithmetic-expression/arithmetic-expression.ts:34

ParserBitwiseExpressionContext

Ƭ ParserBitwiseExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTBitwiseExpressionKind]\>

Union type of all possible kind context classes for a constructable BitwiseExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/bitwise-expression/bitwise-expression.ts:26

ParserBitwiseExpressionRuleName

Ƭ ParserBitwiseExpressionRuleName: typeof KindParseRuleMapping[ASTBitwiseExpressionKind]

Union type of all possible ruleName values for a constructable BitwiseExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/bitwise-expression/bitwise-expression.ts:35

ParserClassMemberDeclarationContext

Ƭ ParserClassMemberDeclarationContext: InstanceTypedeclarationKindToRuleContextMap[ASTClassMemberDeclarationKind]\>

Union type of all possible ParserASTNode context classes for a constructable InterfaceMemberDeclaration AST node.

Since

0.12.0

Defined in

kipper/core/src/compiler/ast/nodes/declarations/type-declaration/class-declaration/class-member-declaration/class-member-declaration.ts:17

ParserClassMemberDeclarationRuleName

Ƭ ParserClassMemberDeclarationRuleName: typeof KindParseRuleMapping[ASTClassMemberDeclarationKind]

Union type of all possible ruleName values for a constructable InterfaceMemberDeclaration AST node.

Since

0.12.0

Defined in

kipper/core/src/compiler/ast/nodes/declarations/type-declaration/class-declaration/class-member-declaration/class-member-declaration.ts:27

ParserComparativeExpressionContext

Ƭ ParserComparativeExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTComparativeExpressionKind]\>

Union type of all possible ParserASTNode context classes for a constructable ComparativeExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/comparative-expression/comparative-expression.ts:24

ParserComparativeExpressionRuleName

Ƭ ParserComparativeExpressionRuleName: typeof KindParseRuleMapping[ASTComparativeExpressionKind]

Union type of all possible ruleName values for a constructable ComparativeExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/comparative-expression/comparative-expression.ts:33

ParserDeclarationContext

Union type of all usable definition/declaration rule context classes implemented by the ParseRuleKindMapping for a Declaration.

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:120

ParserExpressionContext

Union type of all usable expression rule context classes implemented by the ParseRuleKindMapping for an Expression.

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:66

ParserInterfaceMemberDeclarationContext

Ƭ ParserInterfaceMemberDeclarationContext: InstanceTypedeclarationKindToRuleContextMap[ASTInterfaceMemberDeclarationKind]\>

Union type of all possible ParserASTNode context classes for a constructable InterfaceMemberDeclaration AST node.

Since

0.12.0

Defined in

kipper/core/src/compiler/ast/nodes/declarations/type-declaration/interface-declaration/interface-member-declaration/interface-member-declaration.ts:19

ParserInterfaceMemberDeclarationRuleName

Ƭ ParserInterfaceMemberDeclarationRuleName: typeof KindParseRuleMapping[ASTInterfaceMemberDeclarationKind]

Union type of all possible ruleName values for a constructable InterfaceMemberDeclaration AST node.

Since

0.12.0

Defined in

kipper/core/src/compiler/ast/nodes/declarations/type-declaration/interface-declaration/interface-member-declaration/interface-member-declaration.ts:29

ParserIterationStatementContext

Ƭ ParserIterationStatementContext: InstanceTypestatementKindToRuleContextMap[ParserIterationStatementKind]\>

Union type of all possible ParserASTNode context classes for a constructable MemberAccessExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/statements/iteration-statement/iteration-statement.ts:27

ParserIterationStatementKind

Ƭ ParserIterationStatementKind: typeof RULE_forLoopIterationStatement | typeof RULE_whileLoopIterationStatement | typeof RULE_doWhileLoopIterationStatement

Union type of all possible kind values for a constructable MemberAccessExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/statements/iteration-statement/iteration-statement.ts:17

ParserIterationStatementRuleName

Ƭ ParserIterationStatementRuleName: typeof KindParseRuleMapping[ParserIterationStatementKind]

Union type of all possible ruleName values for a constructable MemberAccessExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/statements/iteration-statement/iteration-statement.ts:36

ParserLogicalExpressionContext

Ƭ ParserLogicalExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTLogicalExpressionKind]\>

Union type of all possible kind context classes for a constructable LogicalExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/logical-expression/logical-expression.ts:26

ParserLogicalExpressionRuleName

Ƭ ParserLogicalExpressionRuleName: typeof KindParseRuleMapping[ASTLogicalExpressionKind]

Union type of all possible ruleName values for a constructable LogicalExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/logical-expression/logical-expression.ts:35

ParserPostfixExpressionContext

Ƭ ParserPostfixExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTPostfixExpressionKind]\>

Union type of all possible kind context classes for a constructable PostfixExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/postfix-expression/postfix-expression.ts:26

ParserPostfixExpressionRuleName

Ƭ ParserPostfixExpressionRuleName: typeof KindParseRuleMapping[ASTPostfixExpressionKind]

Union type of all possible ruleName values for a constructable PostfixExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/postfix-expression/postfix-expression.ts:35

ParserPrimaryExpressionContext

Ƭ ParserPrimaryExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTPrimaryExpressionKind]\>

Union type of all possible kind context classes for a constructable PrimaryExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/primary-expression/primary-expression.ts:35

ParserPrimaryExpressionRuleName

Ƭ ParserPrimaryExpressionRuleName: typeof KindParseRuleMapping[ASTPrimaryExpressionKind]

Union type of all possible ruleName values for a constructable PrimaryExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/primary-expression/primary-expression.ts:44

ParserStatementContext

Union type of all usable statement rule context classes implemented by the ParseRuleKindMapping for a Statement.

Defined in

kipper/core/src/compiler/ast/common/ast-types.ts:105

ParserTypeDeclarationContext

Ƭ ParserTypeDeclarationContext: InstanceTypedeclarationKindToRuleContextMap[ASTTypeDeclarationKind]\>

Union type of all possible ParserASTNode context classes for a constructable TypeDeclaration AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/declarations/type-declaration/type-declaration.ts:23

ParserTypeDeclarationRuleName

Ƭ ParserTypeDeclarationRuleName: typeof KindParseRuleMapping[ASTTypeDeclarationKind]

Union type of all possible ruleName values for a constructable TypeDeclaration AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/declarations/type-declaration/type-declaration.ts:32

ParserTypeSpecifierExpressionContext

Ƭ ParserTypeSpecifierExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTTypeSpecifierExpressionKind]\>

Union type of all possible ParserASTNode context classes for a constructable TypeSpecifierExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/type-specifier-expression/type-specifier-expression.ts:26

ParserTypeSpecifierExpressionRuleName

Ƭ ParserTypeSpecifierExpressionRuleName: typeof KindParseRuleMapping[ASTTypeSpecifierExpressionKind]

Union type of all possible ruleName values for a constructable TypeSpecifierExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/type-specifier-expression/type-specifier-expression.ts:35

ParserUnaryExpressionContext

Ƭ ParserUnaryExpressionContext: InstanceTypeexpressionKindToRuleContextMap[ASTUnaryExpressionKind]\>

Union type of all possible ParserASTNode context classes for a constructable UnaryExpression AST node.

Since

0.10.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/unary-expression/unary-expression.ts:25

ParserUnaryExpressionRuleName

Ƭ ParserUnaryExpressionRuleName: typeof KindParseRuleMapping[ASTUnaryExpressionKind]

Union type of all possible ruleName values for a constructable UnaryExpression AST node.

Since

0.11.0

Defined in

kipper/core/src/compiler/ast/nodes/expressions/unary-expression/unary-expression.ts:34

SemanticData

Ƭ SemanticData: Object

Semantics type which defines the blueprint for semanticData inside a CompilableASTNode.

Since

0.3.0

Index signature

▪ [key: string]: any

Defined in

kipper/core/src/compiler/ast/ast-node.ts:18

TargetASTNodeCodeGenerator

Ƭ TargetASTNodeCodeGenerator<T, R>: Function & (node: T) => Promise<R>

Represents a function that translates a Kipper token code into a specific language.

The return may only be of type TranslatedExpression, TranslatedCodeLine or Array.

Since

0.10.0

Type parameters

Name	Type
`T`	extends `CompilableASTNode`
`R`	extends `TranslatedExpression` \| `TranslatedCodeLine` \| `TranslatedCodeLine`[]

Defined in

kipper/core/src/compiler/target-presets/translation/code-generator.ts:75

TargetASTNodeSemanticAnalyser

Ƭ TargetASTNodeSemanticAnalyser<T>: (node: T) => Promise<void>

Type parameters

Name	Type
`T`	extends `AnalysableASTNode`<`SemanticData`, `TypeData`>

Type declaration

▸ (node): Promise<void>

Represents a function that checks the semantics for a AnalysableASTNode.

This function does not interpret but only check the logical integrity of the AST node.

Since

0.10.0

Parameters

Name	Type
`node`	`T`

Returns

Promise<void>

Defined in

kipper/core/src/compiler/target-presets/semantic-analyser.ts:73

TargetSetUpCodeGenerator

Ƭ TargetSetUpCodeGenerator: (programCtx: KipperProgramContext, requirements: TranslatedCodeLine[]) => Promise<TranslatedCodeLine[]>

Type declaration

▸ (programCtx, requirements): Promise<TranslatedCodeLine[]>

Represents a function that generates setup code for a Kipper file.

This is not intended as a replacement to KipperTargetBuiltInGenerator.

Since

0.10.0

Parameters

Name	Type
`programCtx`	`KipperProgramContext`
`requirements`	`TranslatedCodeLine`[]

Returns

Promise<TranslatedCodeLine[]>

Defined in

kipper/core/src/compiler/target-presets/translation/code-generator.ts:86

TargetWrapUpCodeGenerator

Ƭ TargetWrapUpCodeGenerator: (programCtx: KipperProgramContext) => Promise<TranslatedCodeLine[]>

Type declaration

▸ (programCtx): Promise<TranslatedCodeLine[]>

Represents a function that generates wrap up code for a Kipper file.

This is not intended as a replacement to KipperTargetBuiltInGenerator.

Since

0.10.0

Parameters

Name	Type
`programCtx`	`KipperProgramContext`

Returns

Promise<TranslatedCodeLine[]>

Defined in

kipper/core/src/compiler/target-presets/translation/code-generator.ts:97

TranslatedCodeLine

Ƭ TranslatedCodeLine: TranslatedCodeToken[]

Represents a single line of translated Kipper code.

Since

0.5.0

Defined in

kipper/core/src/compiler/const.ts:637

TranslatedCodeToken

Ƭ TranslatedCodeToken: string

Represents a single token of translated Kipper code. This is usually used without a TranslatedCodeLine, which represents a whole translated line of code.

Since

0.5.0

Defined in

kipper/core/src/compiler/const.ts:624

TranslatedExpression

Ƭ TranslatedExpression: TranslatedCodeToken[]

Represents a single translated Kipper expression. This is usually used to represent multiple expression inside a single TranslatedCodeLine.

Since

0.5.0

Defined in

kipper/core/src/compiler/const.ts:631

TypeData

Ƭ TypeData: Object

Type semantics for an expression class that must be evaluated during Type Checking.

Since

0.10.0

Index signature

▪ [key: string]: any

Defined in

kipper/core/src/compiler/ast/ast-node.ts:24

Variables

BuiltInFunctions

• Const BuiltInFunctions: Object

Contains all the built-in functions in Kipper that are available per default in every program.

Type declaration

Name	Type
`len`	`BuiltInFunction`
`print`	`BuiltInFunction`

Defined in

kipper/core/src/compiler/semantics/symbol-table/universe-scope.ts:47

BuiltInTypes

• Const BuiltInTypes: Object

Contains all the built-in types that are used in the type analysis phase.

Since

0.11.0

Type declaration

Name	Type
`Array`	`BuiltInTypeArray`
`Func`	`BuiltInTypeFunc`
`any`	`BuiltInTypeAny`
`bool`	`BuiltInTypeBool`
`null`	`BuiltInTypeNull`
`num`	`BuiltInTypeNum`
`obj`	`BuiltInTypeObj`
`str`	`BuiltInTypeStr`
`type`	`BuiltInTypeType`
`undefined`	`BuiltInTypeUndefined`
`void`	`BuiltInTypeVoid`

Defined in

kipper/core/src/compiler/semantics/symbol-table/universe-scope.ts:30

BuiltInVariables

• Const BuiltInVariables: Object

Contains all the built-in variables in Kipper that are available per default in every program.

Since

0.10.0

Type declaration

Name	Type
`NaN`	`BuiltInVariable`
`__name__`	`BuiltInVariable`

Defined in

kipper/core/src/compiler/semantics/symbol-table/universe-scope.ts:65

COMMENT

• Const COMMENT: 2

The comment channels where all comments are stored.

Since

0.11.0

Defined in

kipper/core/src/compiler/lexer-parser/lexer-channels.ts:19

DEFAULT_TOKEN_CHANNEL

• Const DEFAULT_TOKEN_CHANNEL: 0

The default channel ID which all parser-relevant tokens are stored.

Since

0.11.0

Defined in

kipper/core/src/compiler/lexer-parser/lexer-channels.ts:7

HIDDEN

• Const HIDDEN: 1

The hidden channel where all whitespaces and newlines are stored.

Since

0.11.0

Defined in

kipper/core/src/compiler/lexer-parser/lexer-channels.ts:13

KindParseRuleMapping

• Const KindParseRuleMapping: InverseMap<{ RULE_additiveExpression: 68 = KipperParser.RULE_additiveExpression; RULE_argumentExpressionList: 54 = KipperParser.RULE_argumentExpressionList; RULE_arrayPrimaryExpression: 49 = KipperParser.RULE_arrayPrimaryExpression; RULE_assignmentExpression: 81 = KipperParser.RULE_assignmentExpression; RULE_assignmentOperator: 82 = KipperParser.RULE_assignmentOperator; RULE_bitwiseAndExpression: 75 = KipperParser.RULE_bitwiseAndExpression; RULE_bitwiseOrExpression: 77 = KipperParser.RULE_bitwiseOrExpression; RULE_bitwiseShiftExpression: 69 = KipperParser.RULE_bitwiseShiftExpression; RULE_bitwiseShiftOperators: 70 = KipperParser.RULE_bitwiseShiftOperators; RULE_bitwiseXorExpression: 76 = KipperParser.RULE_bitwiseXorExpression; RULE_blockItem: 4 = KipperParser.RULE_blockItem; RULE_blockItemList: 3 = KipperParser.RULE_blockItemList; RULE_boolPrimaryExpression: 40 = KipperParser.RULE_boolPrimaryExpression; RULE_bracketNotation: 56 = KipperParser.RULE_bracketNotation; RULE_castOrConvertExpression: 66 = KipperParser.RULE_castOrConvertExpression; RULE_classConstructorDeclaration: 23 = KipperParser.RULE_classConstructorDeclaration; RULE_classDeclaration: 19 = KipperParser.RULE_classDeclaration; RULE_classMethodDeclaration: 22 = KipperParser.RULE_classMethodDeclaration; RULE_classPropertyDeclaration: 21 = KipperParser.RULE_classPropertyDeclaration; RULE_compilationUnit: 0 = KipperParser.RULE_compilationUnit; RULE_compoundStatement: 25 = KipperParser.RULE_compoundStatement; RULE_computedPrimaryExpression: 53 = KipperParser.RULE_computedPrimaryExpression; RULE_conditionalExpression: 80 = KipperParser.RULE_conditionalExpression; RULE_declaration: 5 = KipperParser.RULE_declaration; RULE_declarator: 10 = KipperParser.RULE_declarator; RULE_directDeclarator: 11 = KipperParser.RULE_directDeclarator; RULE_doWhileLoopIterationStatement: 34 = KipperParser.RULE_doWhileLoopIterationStatement; RULE_dotNotation: 55 = KipperParser.RULE_dotNotation; RULE_equalityExpression: 74 = KipperParser.RULE_equalityExpression; RULE_expression: 83 = KipperParser.RULE_expression; RULE_expressionStatement: 26 = KipperParser.RULE_expressionStatement; RULE_externalItem: 2 = KipperParser.RULE_externalItem; RULE_fStringDoubleQuoteAtom: 47 = KipperParser.RULE_fStringDoubleQuoteAtom; RULE_fStringPrimaryExpression: 45 = KipperParser.RULE_fStringPrimaryExpression; RULE_fStringSingleQuoteAtom: 46 = KipperParser.RULE_fStringSingleQuoteAtom; RULE_forLoopIterationStatement: 32 = KipperParser.RULE_forLoopIterationStatement; RULE_functionCallExpression: 1002 = 1002; RULE_functionDeclaration: 12 = KipperParser.RULE_functionDeclaration; RULE_genericTypeSpecifierExpression: 86 = KipperParser.RULE_genericTypeSpecifierExpression; RULE_identifier: 42 = KipperParser.RULE_identifier; RULE_identifierOrStringPrimaryExpression: 43 = KipperParser.RULE_identifierOrStringPrimaryExpression; RULE_identifierPrimaryExpression: 41 = KipperParser.RULE_identifierPrimaryExpression; RULE_identifierTypeSpecifierExpression: 85 = KipperParser.RULE_identifierTypeSpecifierExpression; RULE_ifStatement: 28 = KipperParser.RULE_ifStatement; RULE_incrementOrDecrementOperator: 64 = KipperParser.RULE_incrementOrDecrementOperator; RULE_incrementOrDecrementPostfixExpression: 59 = KipperParser.RULE_incrementOrDecrementPostfixExpression; RULE_incrementOrDecrementUnaryExpression: 62 = KipperParser.RULE_incrementOrDecrementUnaryExpression; RULE_initDeclarator: 8 = KipperParser.RULE_initDeclarator; RULE_initializer: 9 = KipperParser.RULE_initializer; RULE_instanceofExpression: 71 = KipperParser.RULE_instanceOfExpression; RULE_interfaceDeclaration: 15 = KipperParser.RULE_interfaceDeclaration; RULE_interfaceMethodDeclaration: 18 = KipperParser.RULE_interfaceMethodDeclaration; RULE_interfacePropertyDeclaration: 17 = KipperParser.RULE_interfacePropertyDeclaration; RULE_iterationStatement: 31 = KipperParser.RULE_iterationStatement; RULE_jumpStatement: 35 = KipperParser.RULE_jumpStatement; RULE_lambdaPrimaryExpression: 38 = KipperParser.RULE_lambdaPrimaryExpression; RULE_logicalAndExpression: 78 = KipperParser.RULE_logicalAndExpression; RULE_logicalOrExpression: 79 = KipperParser.RULE_logicalOrExpression; RULE_matchesExpression: 72 = KipperParser.RULE_matchesExpression; RULE_memberAccessExpression: 1001 = 1001; RULE_multiplicativeExpression: 67 = KipperParser.RULE_multiplicativeExpression; RULE_newInstantiationExpression: 1003 = 1003; RULE_numberPrimaryExpression: 48 = KipperParser.RULE_numberPrimaryExpression; RULE_objectPrimaryExpression: 50 = KipperParser.RULE_objectPrimaryExpression; RULE_objectProperty: 51 = KipperParser.RULE_objectProperty; RULE_operatorModifiedUnaryExpression: 63 = KipperParser.RULE_operatorModifiedUnaryExpression; RULE_parameterDeclaration: 14 = KipperParser.RULE_parameterDeclaration; RULE_parameterList: 13 = KipperParser.RULE_parameterList; RULE_postfixExpression: 58 = KipperParser.RULE_postfixExpression; RULE_primaryExpression: 37 = KipperParser.RULE_primaryExpression; RULE_relationalExpression: 73 = KipperParser.RULE_relationalExpression; RULE_returnStatement: 36 = KipperParser.RULE_returnStatement; RULE_selectionStatement: 27 = KipperParser.RULE_selectionStatement; RULE_sliceNotation: 57 = KipperParser.RULE_sliceNotation; RULE_statement: 24 = KipperParser.RULE_statement; RULE_storageTypeSpecifier: 7 = KipperParser.RULE_storageTypeSpecifier; RULE_stringPrimaryExpression: 44 = KipperParser.RULE_stringPrimaryExpression; RULE_switchLabeledStatement: 30 = KipperParser.RULE_switchLabeledStatement; RULE_switchStatement: 29 = KipperParser.RULE_switchStatement; RULE_tangledPrimaryExpression: 39 = KipperParser.RULE_tangledPrimaryExpression; RULE_translationUnit: 1 = KipperParser.RULE_translationUnit; RULE_typeSpecifierExpression: 84 = KipperParser.RULE_typeSpecifierExpression; RULE_typeSpecifierIdentifier: 88 = KipperParser.RULE_typeSpecifierIdentifier; RULE_typeofExpression: 60 = KipperParser.RULE_typeofExpression; RULE_typeofTypeSpecifierExpression: 87 = KipperParser.RULE_typeofTypeSpecifierExpression; RULE_unaryExpression: 61 = KipperParser.RULE_unaryExpression; RULE_unaryOperator: 65 = KipperParser.RULE_unaryOperator; RULE_variableDeclaration: 6 = KipperParser.RULE_variableDeclaration; RULE_voidOrNullOrUndefinedPrimaryExpression: 52 = KipperParser.RULE_voidOrNullOrUndefinedPrimaryExpression; RULE_whileLoopIterationStatement: 33 = KipperParser.RULE_whileLoopIterationStatement }>

Inverse mapping of ParseRuleKindMapping which maps the AST syntax kind number to the KipperParser rule.

Since

0.11.0

Defined in

kipper/core/src/compiler/lexer-parser/parse-rule-kind-mapping.ts:119

KipperConstructorInternalIdentifierLiteral

• Const KipperConstructorInternalIdentifierLiteral: "\@constructor"

Represents the internal identifier for a Kipper constructor.

Since

0.12.0

Defined in

kipper/core/src/compiler/const.ts:661

PRAGMA

• Const PRAGMA: 3

The pragma channel where all pragma instructions are stored which modify the compiler behaviour.

Since

0.11.0

Defined in

kipper/core/src/compiler/lexer-parser/lexer-channels.ts:25

ParseRuleKindMapping

• Const ParseRuleKindMapping: Object

A mapping object which maps the KipperParser rules to an AST syntax kind number and in extension with the ASTNodeFactory factories to an AST node class implementation.

This mapping is required, since even if the KipperParser implements numbers for each rule, labelled rules are ignored and the parent rule index is used instead. This means that the rule index is not unique and cannot be used for identifying the AST node class for a labelled rule. As such we need a new mapping for the AST generation.

Not every number contained here is mapped to a constructable AST node. Some may be only used for internal purposes inside the parser. For completion’s sake, all numbers are listed here regardless.

Since

0.10.0

Type declaration

Name	Type
`RULE_additiveExpression`	`68`
`RULE_argumentExpressionList`	`54`
`RULE_arrayPrimaryExpression`	`49`
`RULE_assignmentExpression`	`81`
`RULE_assignmentOperator`	`82`
`RULE_bitwiseAndExpression`	`75`
`RULE_bitwiseOrExpression`	`77`
`RULE_bitwiseShiftExpression`	`69`
`RULE_bitwiseShiftOperators`	`70`
`RULE_bitwiseXorExpression`	`76`
`RULE_blockItem`	`4`
`RULE_blockItemList`	`3`
`RULE_boolPrimaryExpression`	`40`
`RULE_bracketNotation`	`56`
`RULE_castOrConvertExpression`	`66`
`RULE_classConstructorDeclaration`	`23`
`RULE_classDeclaration`	`19`
`RULE_classMethodDeclaration`	`22`
`RULE_classPropertyDeclaration`	`21`
`RULE_compilationUnit`	`0`
`RULE_compoundStatement`	`25`
`RULE_computedPrimaryExpression`	`53`
`RULE_conditionalExpression`	`80`
`RULE_declaration`	`5`
`RULE_declarator`	`10`
`RULE_directDeclarator`	`11`
`RULE_doWhileLoopIterationStatement`	`34`
`RULE_dotNotation`	`55`
`RULE_equalityExpression`	`74`
`RULE_expression`	`83`
`RULE_expressionStatement`	`26`
`RULE_externalItem`	`2`
`RULE_fStringDoubleQuoteAtom`	`47`
`RULE_fStringPrimaryExpression`	`45`
`RULE_fStringSingleQuoteAtom`	`46`
`RULE_forLoopIterationStatement`	`32`
`RULE_functionCallExpression`	`1002`
`RULE_functionDeclaration`	`12`
`RULE_genericTypeSpecifierExpression`	`86`
`RULE_identifier`	`42`
`RULE_identifierOrStringPrimaryExpression`	`43`
`RULE_identifierPrimaryExpression`	`41`
`RULE_identifierTypeSpecifierExpression`	`85`
`RULE_ifStatement`	`28`
`RULE_incrementOrDecrementOperator`	`64`
`RULE_incrementOrDecrementPostfixExpression`	`59`
`RULE_incrementOrDecrementUnaryExpression`	`62`
`RULE_initDeclarator`	`8`
`RULE_initializer`	`9`
`RULE_instanceofExpression`	`71`
`RULE_interfaceDeclaration`	`15`
`RULE_interfaceMethodDeclaration`	`18`
`RULE_interfacePropertyDeclaration`	`17`
`RULE_iterationStatement`	`31`
`RULE_jumpStatement`	`35`
`RULE_lambdaPrimaryExpression`	`38`
`RULE_logicalAndExpression`	`78`
`RULE_logicalOrExpression`	`79`
`RULE_matchesExpression`	`72`
`RULE_memberAccessExpression`	`1001`
`RULE_multiplicativeExpression`	`67`
`RULE_newInstantiationExpression`	`1003`
`RULE_numberPrimaryExpression`	`48`
`RULE_objectPrimaryExpression`	`50`
`RULE_objectProperty`	`51`
`RULE_operatorModifiedUnaryExpression`	`63`
`RULE_parameterDeclaration`	`14`
`RULE_parameterList`	`13`
`RULE_postfixExpression`	`58`
`RULE_primaryExpression`	`37`
`RULE_relationalExpression`	`73`
`RULE_returnStatement`	`36`
`RULE_selectionStatement`	`27`
`RULE_sliceNotation`	`57`
`RULE_statement`	`24`
`RULE_storageTypeSpecifier`	`7`
`RULE_stringPrimaryExpression`	`44`
`RULE_switchLabeledStatement`	`30`
`RULE_switchStatement`	`29`
`RULE_tangledPrimaryExpression`	`39`
`RULE_translationUnit`	`1`
`RULE_typeSpecifierExpression`	`84`
`RULE_typeSpecifierIdentifier`	`88`
`RULE_typeofExpression`	`60`
`RULE_typeofTypeSpecifierExpression`	`87`
`RULE_unaryExpression`	`61`
`RULE_unaryOperator`	`65`
`RULE_variableDeclaration`	`6`
`RULE_voidOrNullOrUndefinedPrimaryExpression`	`52`
`RULE_whileLoopIterationStatement`	`33`

Defined in

kipper/core/src/compiler/lexer-parser/parse-rule-kind-mapping.ts:21

defaultOptimisationOptions

• Const defaultOptimisationOptions: OptimisationOptions

The default configuration for OptimisationOptions.

Since

0.8.0

Defined in

kipper/core/src/compiler/optimiser/optimiser.ts:37

isBrowser

• Const isBrowser: boolean

If this variable is true, then this environment is assumed to be inside a browser and special browser support should be applied.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:15

kipperAdditiveOperators

• Const kipperAdditiveOperators: (KipperMinusOperator | KipperPlusOperator)[]

All available additive operations inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:560

kipperAnyTypeLiteral

• Const kipperAnyTypeLiteral: KipperAnyTypeLiteral = "any"

Any type in Kipper, which can be used to represent any type.

Since

0.12.0

Defined in

kipper/core/src/compiler/const.ts:41

kipperArithmeticAssignOperators

• Const kipperArithmeticAssignOperators: KipperArithmeticAssignOperator[]

All available arithmetic assignment operations inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:590

kipperArithmeticOperators

• Const kipperArithmeticOperators: KipperArithmeticOperator[]

All available arithmetic operations inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:575

kipperAssignOperators

• Const kipperAssignOperators: KipperAssignOperator[]

All available assignment operators inside Kipper, which can be used to assign a value to a variable/reference.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:614

kipperBitwiseAndOperator

• Const kipperBitwiseAndOperator: KipperBitwiseAndOperator = "&"

The bitwise-and operator, which can be used to combine two numbers bitwise.

Example

EXP & EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:320

kipperBitwiseNotOperator

• Const kipperBitwiseNotOperator: KipperBitwiseNotOperator = "~"

The bitwise-not operator, which can be used to negate a number bitwise.

Example

~EXP;

Since

0.11.0

Defined in

kipper/core/src/compiler/const.ts:380

kipperBitwiseOrOperator

• Const kipperBitwiseOrOperator: KipperBitwiseOrOperator = "|"

The bitwise-or operator, which can be used to combine two numbers bitwise.

Example

EXP | EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:336

kipperBitwiseShiftOperators

• Const kipperBitwiseShiftOperators: KipperBitwiseShiftOperator[]

All available bitwise operators inside Kipper, which can be used to combine two numbers bitwise.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:348

kipperBitwiseXorOperator

• Const kipperBitwiseXorOperator: KipperBitwiseXorOperator = "^"

The bitwise-xor operator, which can be used to combine two numbers bitwise.

Example

EXP ^ EXP;

Since

0.11.0

Defined in

kipper/core/src/compiler/const.ts:364

kipperBoolTypeLiteral

• Const kipperBoolTypeLiteral: KipperBoolTypeLiteral = "bool"

Boolean type in Kipper.

Since

0.5.0

Example

bool

Defined in

kipper/core/src/compiler/const.ts:161

kipperBuiltInTypeLiterals

• Const kipperBuiltInTypeLiterals: KipperBuiltInTypeLiteral[]

All compilable and valid base types inside Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:223

kipperComparativeOperators

• Const kipperComparativeOperators: KipperComparativeOperator[]

All available comparative operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:426

kipperEqualAssignOperator

• Const kipperEqualAssignOperator: KipperEqualAssignOperator = "="

Default assignment operator for assigning a value to a variable/reference.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:602

kipperEqualityOperators

• Const kipperEqualityOperators: KipperEqualityOperator[]

All available equality operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:402

kipperFuncTypeLiteral

• Const kipperFuncTypeLiteral: KipperFuncTypeLiteral = "Func"

Function type in Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:89

kipperIncrementOrDecrementOperators

• Const kipperIncrementOrDecrementOperators: KipperPostfixOperator[]

Increment and decrement operators, which can be used to modify the value of an expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:507

kipperInternalBuiltInFunctions

• Const kipperInternalBuiltInFunctions: Object

Contains all the internal built-in functions, which are used by Kipper to provide internal functionality. These internal built-ins are commonly used to provide the functionality for keywords and other internal logic.

This contains every builtin that also must be implemented by every target in the KipperTargetBuiltInGenerator.

Since

0.8.0

Type declaration

Name	Type
`boolToNum`	{ `identifier`: `string` = "boolToNum"; `params`: `InternalFunctionArgument`[] ; `returnType`: `BuiltInTypeNum` = BuiltInTypes.num }
`boolToNum.identifier`	`string`
`boolToNum.params`	`InternalFunctionArgument`[]
`boolToNum.returnType`	`BuiltInTypeNum`
`boolToStr`	{ `identifier`: `string` = "boolToStr"; `params`: `InternalFunctionArgument`[] ; `returnType`: `BuiltInTypeStr` = BuiltInTypes.str }
`boolToStr.identifier`	`string`
`boolToStr.params`	`InternalFunctionArgument`[]
`boolToStr.returnType`	`BuiltInTypeStr`
`index`	{ `identifier`: `string` = "index"; `params`: `InternalFunctionArgument`[] ; `returnType`: `UnionType`<[`BuiltInTypeStr`, `BuiltInTypeArray`]> }
`index.identifier`	`string`
`index.params`	`InternalFunctionArgument`[]
`index.returnType`	`UnionType`<[`BuiltInTypeStr`, `BuiltInTypeArray`]>
`nullToStr`	{ `identifier`: `string` = "nullToStr"; `params`: `InternalFunctionArgument`[] ; `returnType`: `BuiltInTypeStr` = BuiltInTypes.str }
`nullToStr.identifier`	`string`
`nullToStr.params`	`InternalFunctionArgument`[]
`nullToStr.returnType`	`BuiltInTypeStr`
`numToStr`	{ `identifier`: `string` = "numToStr"; `params`: `InternalFunctionArgument`[] ; `returnType`: `BuiltInTypeStr` = BuiltInTypes.str }
`numToStr.identifier`	`string`
`numToStr.params`	`InternalFunctionArgument`[]
`numToStr.returnType`	`BuiltInTypeStr`
`repeatString`	{ `identifier`: `string` = "repeatString"; `params`: `InternalFunctionArgument`[] ; `returnType`: `BuiltInTypeStr` = BuiltInTypes.str }
`repeatString.identifier`	`string`
`repeatString.params`	`InternalFunctionArgument`[]
`repeatString.returnType`	`BuiltInTypeStr`
`slice`	{ `identifier`: `string` = "slice"; `params`: `InternalFunctionArgument`[] ; `returnType`: `UnionType`<[`BuiltInTypeStr`, `BuiltInTypeArray`]> }
`slice.identifier`	`string`
`slice.params`	`InternalFunctionArgument`[]
`slice.returnType`	`UnionType`<[`BuiltInTypeStr`, `BuiltInTypeArray`]>
`strToNum`	{ `identifier`: `string` = "strToNum"; `params`: `InternalFunctionArgument`[] ; `returnType`: `BuiltInTypeNum` = BuiltInTypes.num }
`strToNum.identifier`	`string`
`strToNum.params`	`InternalFunctionArgument`[]
`strToNum.returnType`	`BuiltInTypeNum`
`undefinedToStr`	{ `identifier`: `string` = "undefinedToStr"; `params`: `InternalFunctionArgument`[] ; `returnType`: `BuiltInTypeStr` = BuiltInTypes.str }
`undefinedToStr.identifier`	`string`
`undefinedToStr.params`	`InternalFunctionArgument`[]
`undefinedToStr.returnType`	`BuiltInTypeStr`
`voidToStr`	{ `identifier`: `string` = "voidToStr"; `params`: `InternalFunctionArgument`[] ; `returnType`: `BuiltInTypeStr` = BuiltInTypes.str }
`voidToStr.identifier`	`string`
`voidToStr.params`	`InternalFunctionArgument`[]
`voidToStr.returnType`	`BuiltInTypeStr`

Defined in

kipper/core/src/compiler/semantics/runtime-internals/internals.ts:14

kipperListTypeLiteral

• Const kipperListTypeLiteral: KipperListTypeLiteral = "Array"

List type in Kipper. KipperType ValueType represents the type of the list content and only serves as a type checking generic type, it will not change the type itself.

Since

0.5.0

Example

list<T>

Defined in

kipper/core/src/compiler/const.ts:177

kipperLogicalAndOperator

• Const kipperLogicalAndOperator: KipperLogicalAndOperator = "&&"

The logical-and operator, which can be used to combine multiple conditions and return true if all conditions are true.

Example

EXP && EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:274

kipperLogicalOperator

• Const kipperLogicalOperator: KipperLogicalOperator[]

All available logical operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:304

kipperLogicalOrOperator

• Const kipperLogicalOrOperator: KipperLogicalOrOperator = "||"

The logical-or operator, which can be used to combine multiple conditions and return true if at least one condition is true.

Example

EXP || EXP;

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:292

kipperMetaTypeLiteral

• Const kipperMetaTypeLiteral: KipperMetaTypeLiteral = "type"

Represents the meta type in Kipper, which itself is used represents a type e.g. this is the type of a type.

Since

0.8.0

Defined in

kipper/core/src/compiler/const.ts:29

kipperMinusOperator

• Const kipperMinusOperator: KipperMinusOperator = "-"

The minus operator.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:453

kipperMultiplicativeOperators

• Const kipperMultiplicativeOperators: KipperMultiplicativeOperator[]

All available multiplicative operators inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:554

kipperNegateOperator

• Const kipperNegateOperator: KipperNegateOperator = "!"

Negate operator, which can be used to negate a boolean expression. It evaluates to the opposite boolean representation of the original expression.

Example

!true; // false
!false; // true
!1; // false
!0; // true

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:495

kipperNullTypeLiteral

• Const kipperNullTypeLiteral: KipperNullTypeLiteral = "null"

Null type in Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:65

kipperNumTypeLiteral

• Const kipperNumTypeLiteral: KipperNumTypeLiteral = "num"

Numeric type in Kipper.

Since

0.5.0

Example

num

Defined in

kipper/core/src/compiler/const.ts:121

kipperObjTypeLiteral

• Const kipperObjTypeLiteral: KipperObjTypeLiteral = "obj"

Obj type in Kipper.

Since

0.12.0

Defined in

kipper/core/src/compiler/const.ts:53

kipperPlusOperator

• Const kipperPlusOperator: KipperPlusOperator = "+"

The plus operator.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:441

kipperPrimitiveTypeLiterals

• Const kipperPrimitiveTypeLiterals: KipperPrimitiveTypeLiteral[]

All primitive types inside Kipper.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:195

kipperRelationalOperators

• Const kipperRelationalOperators: KipperRelationalOperator[]

All available relational operators inside Kipper, which can be used to compare two expressions against each other.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:414

kipperSignOperators

• Const kipperSignOperators: KipperSignOperator[]

All available sign operators inside Kipper, which can be used to modify the value of a numeric expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:471

kipperStorageTypes

• Const kipperStorageTypes: KipperStorageType[]

All available storage types inside Kipper, which define how a variable is stored/can be accessed.

Since

0.6.0

Defined in

kipper/core/src/compiler/const.ts:258

kipperStrTypeLiteral

• Const kipperStrTypeLiteral: KipperStrTypeLiteral = "str"

String type in Kipper.

Since

0.5.0

Example

str

Defined in

kipper/core/src/compiler/const.ts:137

kipperSupportedConversions

• Const kipperSupportedConversions: [KipperBuiltInTypeLiteral, KipperBuiltInTypeLiteral][]

List of all supported variable type conversions that can be performed in a Kipper program.

For each translation, there will have to be a corresponding generator function, which generates for each conversion the translator function in the specific target.

Since

0.8.0

Defined in

kipper/core/src/compiler/const.ts:239

kipperUnaryModifierOperators

• Const kipperUnaryModifierOperators: KipperUnaryModifierOperator[]

Modifier Unary operators, which are used to modify the value of an expression.

This type specifically exists for the OperatorModifiedUnaryExpression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:523

kipperUnaryOperators

• Const kipperUnaryOperators: KipperUnaryOperator[]

All available unary operators in Kipper, which can be used to modify the value of an expression.

Since

0.9.0

Defined in

kipper/core/src/compiler/const.ts:539

kipperUndefinedTypeLiteral

• Const kipperUndefinedTypeLiteral: KipperUndefinedTypeLiteral = "undefined"

Undefined type in Kipper.

Since

0.10.0

Defined in

kipper/core/src/compiler/const.ts:77

kipperVoidTypeLiteral

• Const kipperVoidTypeLiteral: KipperVoidTypeLiteral = "void"

Void type in Kipper.

Since

0.5.0

Example

void

Defined in

kipper/core/src/compiler/const.ts:105

Functions

handleSemanticError

▸ handleSemanticError(node, error): void

Handles the specified error that occurred during the semantic analysis of a node in a standardised way.

Since

0.10.0

Parameters

Name	Type	Description
`node`	`RootASTNode` \| `AnalysableASTNode`<`SemanticData`, `TypeData`>	The node that is currently being processed.
`error`	`KipperError` \| `Error`	The error to handle.

Returns

void

Defined in

kipper/core/src/compiler/semantics/handle-error.ts:25

shouldRecoverFromError

▸ shouldRecoverFromError(node, error): boolean

Checks whether the given error should be recovered from or not.

Since

0.10.0

Parameters

Name	Type	Description
`node`	`RootASTNode` \| `AnalysableASTNode`<`SemanticData`, `TypeData`>	The node that is currently being processed.
`error`	`KipperError` \| `Error`	The error to check.

Returns

boolean

Defined in

kipper/core/src/compiler/semantics/handle-error.ts:14

Namespace: compiler

Table of contents

Classes

Interfaces

Type Aliases

Variables

Functions

Type Aliases

ASTArithmeticExpressionKind

Defined in

ASTBitwiseExpressionKind

Defined in

ASTClassMemberDeclarationKind

Defined in

ASTComparativeExpressionKind

Defined in

ASTDeclarationKind

Defined in

ASTDeclarationRuleName

Defined in

ASTExpressionKind

Defined in

ASTExpressionRuleName

Defined in

ASTInterfaceMemberDeclarationKind

Defined in

ASTKind

Defined in

ASTLogicalExpressionKind

Defined in

ASTNodeParserContext

Defined in

ASTPostfixExpressionKind

Defined in

ASTPrimaryExpressionKind

Defined in

ASTStatementKind

Defined in

ASTStatementRuleName

Defined in

ASTTypeDeclarationKind

Defined in

ASTTypeSpecifierExpressionKind

Defined in

ASTUnaryExpressionKind

Defined in

AnalysableNodeChild

Defined in

AnalysableNodeParent

Defined in

BuiltInTypeArrayGenericArguments

Defined in

BuiltInTypeFuncGenericArguments

Defined in

CompilableNodeChild

Defined in

CompilableNodeParent

Defined in

ConstructableASTDeclaration

Defined in

ConstructableASTDeclarationClass

Defined in

ConstructableASTExpression

Defined in

ConstructableASTExpressionClass

Defined in

ConstructableASTKind

Defined in

ConstructableASTNode

Defined in

ConstructableASTNodeClass

Defined in

ConstructableASTRuleName

Defined in

ConstructableASTStatement

Defined in

ConstructableASTStatementClass

Defined in

CustomTypeField

Defined in