public IfAction(ParseInfo parseInfo, Scope scope, DeltinScriptParser.IfContext ifContext)
{
// Get the if condition.
if (ifContext.expr() != null)
{
Expression = DeltinScript.GetExpression(parseInfo, scope, ifContext.expr());
}
else
{
parseInfo.Script.Diagnostics.Error("Expected expression.", DocRange.GetRange(ifContext.LEFT_PAREN()));
}
// Contains the path info of all blocks in the if/else-if/else list.
var paths = new List <PathInfo>();
// Get the if's block.
if (ifContext.block() != null)
{
Block = new BlockAction(parseInfo, scope, ifContext.block());
}
else
{
parseInfo.Script.Diagnostics.Error("Expected block.", DocRange.GetRange(ifContext.IF()));
}
// Add the if block path info.
paths.Add(new PathInfo(Block, DocRange.GetRange(ifContext.IF()), false));
// Get the else-ifs.
if (ifContext.else_if() != null)
{
ElseIfs = new ElseIf[ifContext.else_if().Length];
for (int i = 0; i < ElseIfs.Length; i++)
{
ElseIfs[i] = new ElseIf(parseInfo, scope, ifContext.else_if(i));
paths.Add(new PathInfo(Block, DocRange.GetRange(ifContext.else_if(i).ELSE(), ifContext.else_if(i).IF()), false));
}
}
// If there is none, set `ElseIfs` to an empty array since it should not be null.
else
{
ElseIfs = new ElseIf[0];
}
// If there is an else statement, get the else block.
if (ifContext.@else() != null)
{
if (ifContext.block() == null)
{
parseInfo.Script.Diagnostics.Error("Expected block.", DocRange.GetRange(ifContext.@else().block()));
}
else
{
ElseBlock = new BlockAction(parseInfo, scope, ifContext.@else().block());
}
// Add the else path info.
paths.Add(new PathInfo(ElseBlock, DocRange.GetRange(ifContext.@else().ELSE()), true));
}
Paths = paths.ToArray();
}
public override void Call(ParseInfo parseInfo, DocRange callRange)
{
base.Call(parseInfo, callRange);
parseInfo.Script.Elements.AddDeclarationCall(Provider, new DeclarationCall(callRange, false));
parseInfo.Script.AddDefinitionLink(callRange, Provider.DefinedAt);
}
public VarInfo(string name, Location definedAt, ParseInfo parseInfo)
{
Name = name;
DefinedAt = definedAt;
ParseInfo = parseInfo;
}
public ParseReturnHandler(ParseInfo parseInfo)
{
_parseInfo = parseInfo;
}
public void Call(ParseInfo parseInfo, DocRange callRange)
{
IVariableInstance.Call(this, parseInfo, callRange);
parseInfo.Script.AddDefinitionLink(callRange, Var.DefinedAt);
}
public DefineContextHandler(ParseInfo parseInfo, VariableDeclaration defineContext)
{
_defineContext = defineContext;
ParseInfo = parseInfo;
}
public virtual void Call(ParseInfo parseInfo, DocRange callRange)
{
parseInfo.Script.AddHover(callRange, GetLabel(true));
}
void Translate()
{
AddComponent <RecursionCheckComponent>();
// Get the enums
foreach (ScriptFile script in Importer.ScriptFiles)
{
foreach (var enumContext in script.Context.Enums)
{
var newEnum = new GenericCodeTypeInitializer(new DefinedEnum(new ParseInfo(script, this), enumContext));
RulesetScope.AddType(newEnum);
Types.AllTypes.Add(newEnum);
Types.DefinedTypes.Add(newEnum);
}
}
// Get the types
foreach (ScriptFile script in Importer.ScriptFiles)
{
foreach (var typeContext in script.Context.Classes)
{
var newType = IDefinedTypeInitializer.GetInitializer(new ParseInfo(script, this), RulesetScope, typeContext);
RulesetScope.AddType(newType);
Types.AllTypes.Add(newType);
Types.DefinedTypes.Add(newType);
}
}
// Get the variable reservations
foreach (ScriptFile script in Importer.ScriptFiles)
{
foreach (Token reservation in script.Context.GlobalvarReservations)
{
string text = reservation.GetText().RemoveQuotes();
if (Int32.TryParse(text, out int id))
{
VarCollection.Reserve(id, true, script.Diagnostics, reservation.Range);
}
else
{
VarCollection.Reserve(text, true);
}
}
foreach (Token reservation in script.Context.PlayervarReservations)
{
string text = reservation.GetText().RemoveQuotes();
if (Int32.TryParse(text, out int id))
{
VarCollection.Reserve(id, false, script.Diagnostics, reservation.Range);
}
else
{
VarCollection.Reserve(text, false);
}
}
}
// Get variable declarations
foreach (ScriptFile script in Importer.ScriptFiles)
{
foreach (var declaration in script.Context.Declarations)
{
if (declaration is VariableDeclaration variable)
{
Var var = new RuleLevelVariable(RulesetScope, new DefineContextHandler(new ParseInfo(script, this), variable)).GetVar();
if (var.StoreType != StoreType.None)
{
rulesetVariables.Add(var);
// Add the variable to the player variables scope if it is a player variable.
if (var.VariableType == VariableType.Player)
{
PlayerVariableScope.CopyVariable(var.GetDefaultInstance(null));
}
}
}
}
}
ElementList.AddWorkshopFunctionsToScope(GlobalScope, Types); // Add workshop methods to global scope.
GlobalFunctions.GlobalFunctions.Add(this, GlobalScope); // Add built-in methods.
// Get the function declarations
foreach (ScriptFile script in Importer.ScriptFiles)
{
ParseInfo parseInfo = new ParseInfo(script, this);
foreach (var declaration in script.Context.Declarations)
{
if (declaration is FunctionContext function)
{
DefinedMethodProvider.GetDefinedMethod(parseInfo, this, function, null);
}
}
}
StagedInitiation.Start();
// Get hooks
foreach (ScriptFile script in Importer.ScriptFiles)
{
foreach (var hookContext in script.Context.Hooks)
{
HookVar.GetHook(new ParseInfo(script, this), RulesetScope, hookContext);
}
}
// Get the rules
foreach (ScriptFile script in Importer.ScriptFiles)
{
foreach (var ruleContext in script.Context.Rules)
{
rules.Add(new RuleAction(new ParseInfo(script, this), RulesetScope, ruleContext));
}
}
GetComponent <SymbolLinkComponent>().Collect();
}
public virtual void Call(ParseInfo parseInfo, DocRange callRange)
{
}
private void GetRuleSettings(ParseInfo parseInfo, Scope scope, RuleContext ruleContext)
{
RuleSetting teamContext = null, playerContext = null;
bool setEventType = false, setTeam = false, setPlayer = false;
foreach (var setting in ruleContext.Settings)
{
// Add completion.
switch (setting.Setting.Text)
{
case "Event": AddCompletion(parseInfo, setting.Dot, setting.Value, EventItems); break;
case "Team": AddCompletion(parseInfo, setting.Dot, setting.Value, TeamItems); break;
case "Player": AddCompletion(parseInfo, setting.Dot, setting.Value, PlayerItems); break;
}
// Get the value.
if (setting.Value != null)
{
var alreadySet = new Diagnostic("The " + setting.Setting.Text + " rule setting was already set.", setting.Range, Diagnostic.Error);
string name = setting.Value.Text;
DocRange range = setting.Value.Range;
switch (setting.Setting.Text)
{
case "Event":
if (setEventType)
{
parseInfo.Script.Diagnostics.AddDiagnostic(alreadySet);
}
EventType = GetMember <RuleEvent>("Event", name, parseInfo.Script.Diagnostics, range);
setEventType = true;
break;
case "Team":
if (setTeam)
{
parseInfo.Script.Diagnostics.AddDiagnostic(alreadySet);
}
Team = GetMember <Team>("Team", name, parseInfo.Script.Diagnostics, range);
setTeam = true;
teamContext = setting;
break;
case "Player":
if (setPlayer)
{
parseInfo.Script.Diagnostics.AddDiagnostic(alreadySet);
}
Player = GetMember <PlayerSelector>("Player", name, parseInfo.Script.Diagnostics, range);
setPlayer = true;
playerContext = setting;
break;
default:
parseInfo.Script.Diagnostics.Error("Expected an enumerator of type 'Event', 'Team', or 'Player'.", setting.Setting.Range);
break;
}
}
}
// Set the event type to player if the event type was not set and player or team was changed.
if (!setEventType && ((setPlayer && Player != PlayerSelector.All) || (setTeam && Team != Team.All)))
{
EventType = RuleEvent.OngoingPlayer;
}
if (setEventType && EventType == RuleEvent.OngoingGlobal)
{
// Syntax error if the event type is global and the team type is not default.
if (Team != Team.All)
{
parseInfo.Script.Diagnostics.Error("Can't change rule Team type with an event type of Ongoing Global.", teamContext.Range);
}
// Syntax error if the event type is global and the player type is not default.
if (Player != PlayerSelector.All)
{
parseInfo.Script.Diagnostics.Error("Can't change rule Player type with an event type of Ongoing Global.", playerContext.Range);
}
}
}
public override void Call(ParseInfo parseInfo, DocRange callRange)
{
parseInfo.Script.AddDefinitionLink(callRange, DefinedAt);
parseInfo.CurrentCallInfo?.Call(_recursiveCallHandler, callRange);
((DefinedType)Type).AddLink(parseInfo.GetLocation(callRange));
}
public ReferenceCodeLensRange(ICallable callable, ParseInfo parseInfo, CodeLensSourceType sourceType, DocRange range) : base(sourceType, range, "ostw.showReferences")
{
Callable = callable;
_parseInfo = parseInfo;
}
public VariableApply(ParseInfo parseInfo)
{
_parseInfo = parseInfo;
}
public OperatorAction(ParseInfo parseInfo, Scope scope, DeltinScriptParser.E_op_compareContext context)
{
GetParts(parseInfo, scope, context.left, context.op.Text, DocRange.GetRange(context.op), context.right);
}
public DefinedMethod(ParseInfo parseInfo, Scope objectScope, Scope staticScope, DeltinScriptParser.Define_methodContext context, CodeType containingType)
: base(parseInfo, context.name.Text, new Location(parseInfo.Script.Uri, DocRange.GetRange(context.name)))
{
this.context = context;
Attributes.ContainingType = containingType;
DocRange nameRange = DocRange.GetRange(context.name);
// Get the attributes.
GetAttributes();
SetupScope(Static ? staticScope : objectScope);
// Get the type.
if (context.VOID() == null)
{
doesReturnValue = true;
ReturnType = CodeType.GetCodeTypeFromContext(parseInfo, context.code_type());
}
// Setup the parameters and parse the block.
if (!IsSubroutine)
{
SetupParameters(context.setParameters(), false);
}
else
{
Attributes.Parallelable = true;
parseInfo.TranslateInfo.AddSubroutine(this);
// Subroutines should not have parameters.
SetupParameters(context.setParameters(), true);
}
// Override attribute.
if (Attributes.Override)
{
IMethod overriding = objectScope.GetMethodOverload(this);
// No method with the name and parameters found.
if (overriding == null)
{
parseInfo.Script.Diagnostics.Error("Could not find a method to override.", nameRange);
}
else if (!overriding.Attributes.IsOverrideable)
{
parseInfo.Script.Diagnostics.Error("The specified method is not marked as virtual.", nameRange);
}
else
{
overriding.Attributes.AddOverride(this);
}
if (overriding != null && overriding.DefinedAt != null)
{
// Make the override keyword go to the base method.
parseInfo.Script.AddDefinitionLink(
attributes.First(at => at.Type == MethodAttributeType.Override).Range,
overriding.DefinedAt
);
}
}
if (Attributes.IsOverrideable && AccessLevel == AccessLevel.Private)
{
parseInfo.Script.Diagnostics.Error("A method marked as virtual or abstract must have the protection level 'public' or 'protected'.", nameRange);
}
// Syntax error if the block is missing.
if (context.block() == null)
{
parseInfo.Script.Diagnostics.Error("Expected block.", nameRange);
}
// Add to the scope. Check for conflicts if the method is not overriding.
objectScope.AddMethod(this, parseInfo.Script.Diagnostics, nameRange, !Attributes.Override);
// Add the hover info.
parseInfo.Script.AddHover(DocRange.GetRange(context.name), GetLabel(true));
if (Attributes.IsOverrideable)
{
parseInfo.Script.AddCodeLensRange(new ImplementsCodeLensRange(this, parseInfo.Script, CodeLensSourceType.Function, nameRange));
}
parseInfo.TranslateInfo.ApplyBlock(this);
}
public override void Call(ParseInfo parseInfo, DocRange callRange)
{
base.Call(parseInfo, callRange);
parseInfo.Script.AddDefinitionLink(callRange, DefinedAt);
AddLink(new LanguageServer.Location(parseInfo.Script.Uri, callRange));
}
public DefinedMethod(ParseInfo parseInfo, Scope objectScope, Scope staticScope, FunctionContext context, CodeType containingType)
: base(parseInfo, context.Identifier.Text, new Location(parseInfo.Script.Uri, context.Identifier.Range))
{
this.Context = context;
Attributes.ContainingType = containingType;
DocRange nameRange = context.Identifier.Range;
// Get the attributes.
MethodAttributeAppender attributeResult = new MethodAttributeAppender(Attributes);
MethodAttributesGetter attributeGetter = new MethodAttributesGetter(context, attributeResult);
attributeGetter.GetAttributes(parseInfo.Script.Diagnostics);
// Copy attribute results
Static = attributeResult.Static;
IsSubroutine = attributeResult.IsSubroutine;
SubroutineName = attributeResult.SubroutineName;
AccessLevel = attributeResult.AccessLevel;
// Setup scope.
SetupScope(Static ? staticScope : objectScope);
methodScope.MethodContainer = true;
// Get the type.
if (!context.Type.IsVoid)
{
DoesReturnValue = true;
CodeType = CodeType.GetCodeTypeFromContext(parseInfo, context.Type);
}
// Setup the parameters and parse the block.
if (!IsSubroutine)
{
SetupParameters(context.Parameters, false);
}
else
{
SubroutineDefaultGlobal = context.PlayerVar == null;
Attributes.Parallelable = true;
// Subroutines should not have parameters.
SetupParameters(context.Parameters, true);
}
// Override attribute.
if (Attributes.Override)
{
IMethod overriding = objectScope.GetMethodOverload(this);
Attributes.Overriding = overriding;
// No method with the name and parameters found.
if (overriding == null)
{
parseInfo.Script.Diagnostics.Error("Could not find a method to override.", nameRange);
}
else if (!overriding.Attributes.IsOverrideable)
{
parseInfo.Script.Diagnostics.Error("The specified method is not marked as virtual.", nameRange);
}
else
{
overriding.Attributes.AddOverride(this);
}
if (overriding != null && overriding.DefinedAt != null)
{
// Make the override keyword go to the base method.
parseInfo.Script.AddDefinitionLink(
attributeGetter.ObtainedAttributes.First(at => at.Type == MethodAttributeType.Override).Range,
overriding.DefinedAt
);
if (!Attributes.Recursive)
{
Attributes.Recursive = overriding.Attributes.Recursive;
}
}
}
if (Attributes.IsOverrideable && AccessLevel == AccessLevel.Private)
{
parseInfo.Script.Diagnostics.Error("A method marked as virtual or abstract must have the protection level 'public' or 'protected'.", nameRange);
}
// Add to the scope. Check for conflicts if the method is not overriding.
containingScope.AddMethod(this, parseInfo.Script.Diagnostics, nameRange, !Attributes.Override);
// Add the hover info.
parseInfo.Script.AddHover(nameRange, GetLabel(true));
if (Attributes.IsOverrideable)
{
parseInfo.Script.AddCodeLensRange(new ImplementsCodeLensRange(this, parseInfo.Script, CodeLensSourceType.Function, nameRange));
}
parseInfo.TranslateInfo.ApplyBlock(this);
}
public void CheckConflict(ParseInfo parseInfo, CheckConflict identifier, DocRange range) => RulesetScope.CheckConflict(parseInfo, identifier, range);
private void GetRuleSettings(ParseInfo parseInfo, Scope scope, DeltinScriptParser.Ow_ruleContext ruleContext)
{
DeltinScriptParser.ExprContext eventContext = null;
DeltinScriptParser.ExprContext teamContext = null;
DeltinScriptParser.ExprContext playerContext = null;
foreach (var exprContext in ruleContext.expr())
{
_missingBlockRange = DocRange.GetRange(exprContext);
var enumSetting = (DeltinScript.GetExpression(parseInfo, scope, exprContext) as ExpressionTree)?.Result as ScopedEnumMember;
var enumData = (enumSetting?.Enum as WorkshopEnumType)?.EnumData;
if (enumData == null || !ValidRuleEnums.Contains(enumData))
{
parseInfo.Script.Diagnostics.Error("Expected enum of type " + string.Join(", ", ValidRuleEnums.Select(vre => vre.CodeName)) + ".", DocRange.GetRange(exprContext));
}
else
{
var alreadySet = new Diagnostic("The " + enumData.CodeName + " rule setting was already set.", DocRange.GetRange(exprContext), Diagnostic.Error);
// Get the Event option.
if (enumData == EnumData.GetEnum <RuleEvent>())
{
if (_setEventType)
{
parseInfo.Script.Diagnostics.AddDiagnostic(alreadySet);
}
EventType = (RuleEvent)enumSetting.EnumMember.Value;
_setEventType = true;
eventContext = exprContext;
}
// Get the Team option.
if (enumData == EnumData.GetEnum <Team>())
{
if (_setTeam)
{
parseInfo.Script.Diagnostics.AddDiagnostic(alreadySet);
}
Team = (Team)enumSetting.EnumMember.Value;
_setTeam = true;
teamContext = exprContext;
}
// Get the Player option.
if (enumData == EnumData.GetEnum <PlayerSelector>())
{
if (_setPlayer)
{
parseInfo.Script.Diagnostics.AddDiagnostic(alreadySet);
}
Player = (PlayerSelector)enumSetting.EnumMember.Value;
_setPlayer = true;
playerContext = exprContext;
}
}
}
// Syntax error if changing the Team type when the Event type is set to Global.
if (_setEventType && EventType == RuleEvent.OngoingGlobal)
{
if (Team != Team.All)
{
parseInfo.Script.Diagnostics.Error("Can't change rule Team type with an event type of Ongoing Global.", DocRange.GetRange(teamContext));
}
if (Player != PlayerSelector.All)
{
parseInfo.Script.Diagnostics.Error("Can't change rule Player type with an event type of Ongoing Global.", DocRange.GetRange(playerContext));
}
}
}
public void Call(ParseInfo parseInfo, DocRange callRange)
{
parseInfo.Script.AddDefinitionLink(callRange, DefinedAt);
parseInfo.Script.AddHover(callRange, GetLabel(true));
parseInfo.TranslateInfo.GetComponent <SymbolLinkComponent>().AddSymbolLink(this, new Location(parseInfo.Script.Uri, callRange));
}
public CallMethodAction(ParseInfo parseInfo, Scope scope, DeltinScriptParser.MethodContext methodContext, bool usedAsExpression, Scope getter)
{
this.parseInfo = parseInfo;
string methodName = methodContext.PART().GetText();
NameRange = DocRange.GetRange(methodContext.PART());
UsedAsExpression = usedAsExpression;
if (methodContext.ASYNC() != null)
{
if (methodContext.NOT() == null)
{
Parallel = CallParallel.AlreadyRunning_RestartRule;
}
else
{
Parallel = CallParallel.AlreadyRunning_DoNothing;
}
}
var options = scope.GetMethodsByName(methodName);
if (options.Length == 0)
{
parseInfo.Script.Diagnostics.Error($"No method by the name of '{methodName}' exists in the current context.", NameRange);
}
else
{
OverloadChooser = new OverloadChooser(options, parseInfo, scope, getter, NameRange, DocRange.GetRange(methodContext), new OverloadError("method '" + methodName + "'"));
if (methodContext.call_parameters() != null)
{
OverloadChooser.SetContext(methodContext.call_parameters());
}
else if (methodContext.picky_parameters() != null)
{
OverloadChooser.SetContext(methodContext.picky_parameters());
}
else
{
OverloadChooser.SetContext();
}
CallingMethod = (IMethod)OverloadChooser.Overload;
ParameterValues = OverloadChooser.Values;
if (CallingMethod != null)
{
if (CallingMethod is DefinedFunction definedFunction)
{
definedFunction.OnBlockApply(this);
definedFunction.Call(parseInfo.Script, NameRange);
parseInfo.CurrentCallInfo?.Call(definedFunction, NameRange);
}
if (Parallel != CallParallel.NoParallel && !CallingMethod.Attributes.Parallelable)
{
parseInfo.Script.Diagnostics.Error($"The method '{CallingMethod.Name}' cannot be called in parallel.", NameRange);
}
parseInfo.Script.AddHover(DocRange.GetRange(methodContext), CallingMethod.GetLabel(true));
}
}
}
void Translate()
{
// Get the reserved variables and IDs
foreach (ScriptFile script in Importer.ScriptFiles)
{
if (script.Context.reserved_global()?.reserved_list() != null)
{
foreach (var name in script.Context.reserved_global().reserved_list().PART())
{
VarCollection.Reserve(name.GetText(), true);
}
foreach (var id in script.Context.reserved_global().reserved_list().NUMBER())
{
VarCollection.Reserve(int.Parse(id.GetText()), true, null, null);
}
}
if (script.Context.reserved_player()?.reserved_list() != null)
{
foreach (var name in script.Context.reserved_player().reserved_list().PART())
{
VarCollection.Reserve(name.GetText(), false);
}
foreach (var id in script.Context.reserved_player().reserved_list().NUMBER())
{
VarCollection.Reserve(int.Parse(id.GetText()), false, null, null);
}
}
}
// Get the enums
foreach (ScriptFile script in Importer.ScriptFiles)
{
foreach (var enumContext in script.Context.enum_define())
{
var newEnum = new DefinedEnum(new ParseInfo(script, this), enumContext);
Types.AllTypes.Add(newEnum);
Types.DefinedTypes.Add(newEnum);
Types.CalledTypes.Add(newEnum);
}
}
// Get the types
foreach (ScriptFile script in Importer.ScriptFiles)
{
foreach (var typeContext in script.Context.type_define())
{
var newType = new DefinedType(new ParseInfo(script, this), GlobalScope, typeContext);
Types.AllTypes.Add(newType);
Types.DefinedTypes.Add(newType);
Types.CalledTypes.Add(newType);
}
}
// Get the methods and macros
foreach (ScriptFile script in Importer.ScriptFiles)
{
ParseInfo parseInfo = new ParseInfo(script, this);
// Get the methods.
foreach (var methodContext in script.Context.define_method())
{
new DefinedMethod(parseInfo, RulesetScope, RulesetScope, methodContext, null);
}
// Get the macros.
foreach (var macroContext in script.Context.define_macro())
{
parseInfo.GetMacro(RulesetScope, RulesetScope, macroContext);
}
}
// Get the defined variables.
foreach (ScriptFile script in Importer.ScriptFiles)
{
foreach (var varContext in script.Context.define())
{
Var newVar = new RuleLevelVariable(RulesetScope, new DefineContextHandler(new ParseInfo(script, this), varContext));
rulesetVariables.Add(newVar);
// Add the variable to the player variables scope if it is a player variable.
if (newVar.VariableType == VariableType.Player)
{
PlayerVariableScope.CopyVariable(newVar);
}
}
}
foreach (var applyType in Types.AllTypes)
{
if (applyType is ClassType classType)
{
classType.ResolveElements();
}
}
foreach (var apply in applyBlocks)
{
apply.SetupParameters();
}
foreach (var apply in applyBlocks)
{
apply.SetupBlock();
}
foreach (var apply in applyBlocks)
{
apply.CallInfo?.CheckRecursion();
}
// Get the rules
foreach (ScriptFile script in Importer.ScriptFiles)
{
foreach (var ruleContext in script.Context.ow_rule())
{
rules.Add(new RuleAction(new ParseInfo(script, this), RulesetScope, ruleContext));
}
}
}
public ForAction(ParseInfo parseInfo, Scope scope, For forContext)
{
Scope varScope = scope.Child();
IsAutoFor = forContext.Iterator is ExpressionStatement;
// Get the initializer.
if (!IsAutoFor)
{
// Normal for loop initializer.
if (forContext.Initializer != null)
{
// Declaration for initializer.
if (forContext.Initializer is VariableDeclaration declaration)
{
DefinedVariable = new ScopedVariable(varScope, new DefineContextHandler(parseInfo, declaration));
}
// Variable assignment for initializer
else if (forContext.Initializer is Assignment assignment)
{
Initializer = new SetVariableAction(parseInfo, varScope, assignment);
}
// TODO: Throw error on incorrect initializer type.
}
}
else
{
// Auto-for initializer.
// Missing initializer.
if (forContext.Initializer == null)
{
// Error if there is no initializer.
if (forContext.InitializerSemicolon)
{
parseInfo.Script.Diagnostics.Error("Auto-for loops require an initializer.", forContext.InitializerSemicolon.Range);
}
}
// Declaration
else if (forContext.Initializer is VariableDeclaration declaration)
{
DefinedVariable = new ScopedVariable(varScope, new DefineContextHandler(parseInfo, declaration));
}
// Assignment
else if (forContext.Initializer is Assignment assignment)
{
// Get the variable being set.
VariableResolve = new VariableResolve(new VariableResolveOptions()
{
// The for cannot be indexed and should be on the rule-level.
CanBeIndexed = false,
FullVariable = true
}, parseInfo.GetExpression(varScope, assignment.VariableExpression), assignment.VariableExpression.Range, parseInfo.Script.Diagnostics);
InitialResolveValue = parseInfo.GetExpression(scope, assignment.Value);
}
// Variable
else if (forContext.Initializer is ExpressionStatement exprStatement && exprStatement.Expression is Identifier identifier)
{
// The variable is defined but no start value was given. In this case, just start at 0.
// Get the variable.
VariableResolve = new VariableResolve(new VariableResolveOptions()
{
// The for cannot be indexed and should be on the rule-level.
CanBeIndexed = false,
FullVariable = true
}, parseInfo.GetExpression(varScope, identifier), identifier.Range, parseInfo.Script.Diagnostics);
}
public override void Call(ParseInfo parseInfo, DocRange callRange)
{
base.Call(parseInfo, callRange);
parseInfo.Script.AddDefinitionLink(callRange, DefinedAt);
_translateInfo.GetComponent <SymbolLinkComponent>().AddSymbolLink(this, new Location(parseInfo.Script.Uri, callRange));
}
public InverseAction(ParseInfo parseInfo, Scope scope, DeltinScriptParser.ExprContext exprContext)
{
Expression = DeltinScript.GetExpression(parseInfo, scope, exprContext);
}
public ParseReturnHandler(ParseInfo parseInfo, string objectName) : this(parseInfo)
{
VoidReturnValueMessage = objectName + " is void, so no value can be returned.";
}
public OperatorAction(ParseInfo parseInfo, Scope scope, DeltinScriptParser.E_op_boolContext context)
{
GetParts(parseInfo, scope, context.left, context.BOOL().GetText(), DocRange.GetRange(context.BOOL()), context.right);
}
/// <summary>Calls a type from the specified document range.</summary>
/// <param name="parseInfo">The script that the type was called from.</param>
/// <param name="callRange">The range of the call.</param>
public virtual void Call(ParseInfo parseInfo, DocRange callRange)
{
parseInfo.TranslateInfo.Types.CallType(this);
parseInfo.Script.AddHover(callRange, HoverHandler.Sectioned(Kind + " " + Name, Description));
parseInfo.Script.AddToken(callRange, TokenType, TokenModifiers.ToArray());
}
public void Call(ParseInfo parseInfo, DocRange callRange)
{
parseInfo.Script.AddDefinitionLink(callRange, DefinedAt);
parseInfo.TranslateInfo.GetComponent <SymbolLinkComponent>().AddSymbolLink(this, new Location(parseInfo.Script.Uri, callRange));
parseInfo.CurrentCallInfo.Call(_recursiveCallHandler, callRange);
}