1084 lines
50 KiB
C#
1084 lines
50 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using Upsilon.BaseTypes;
|
|
using Upsilon.BaseTypes.Number;
|
|
using Upsilon.Binder.VariableSymbols;
|
|
using Upsilon.BoundTypes;
|
|
using Upsilon.Evaluator;
|
|
using Upsilon.Parser;
|
|
using Type = Upsilon.BaseTypes.Type;
|
|
|
|
namespace Upsilon.Binder
|
|
{
|
|
public class Binder : IDisposable
|
|
{
|
|
private Diagnostics _diagnostics;
|
|
public BoundScope Scope { get; private set; }
|
|
private readonly Script _script;
|
|
|
|
private List<UnboundFunctionExpression> _unboundFunctions =
|
|
new List<UnboundFunctionExpression>();
|
|
|
|
public Binder(Diagnostics diagnostics, Dictionary<string, VariableSymbol> variables, Script script)
|
|
{
|
|
_diagnostics = diagnostics;
|
|
_script = script;
|
|
Scope = new BoundScope(variables, null);
|
|
}
|
|
|
|
private Binder(Script script)
|
|
{
|
|
_script = script;
|
|
}
|
|
|
|
internal static Binder CreateWithSetScope(Diagnostics diagnostics, BoundScope scope, Script script)
|
|
{
|
|
return new Binder(script) {_diagnostics = diagnostics, Scope = scope};
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Scope?.Dispose();
|
|
Scope = null;
|
|
_unboundFunctions.Clear();
|
|
}
|
|
|
|
public BoundScript BindScript(string fileName, BlockStatementSyntax e)
|
|
{
|
|
var bound = BindStatement(e);
|
|
foreach (var unboundFunctionStatement in _unboundFunctions)
|
|
{
|
|
Scope = new BoundScope(Scope);
|
|
foreach (var valueParameter in unboundFunctionStatement.Parameters)
|
|
{
|
|
Scope.AssignToNearest(valueParameter.VariableSymbol);
|
|
if (valueParameter.VariableSymbol.TypeContainer == Type.Unknown)
|
|
_diagnostics.LogUnknownVariableType(valueParameter.VariableSymbol.Name, valueParameter.Span);
|
|
}
|
|
unboundFunctionStatement.Block =
|
|
(BoundBlockStatement) BindBlockStatement(unboundFunctionStatement.UnboundBlock);
|
|
Scope = Scope.ParentScope;
|
|
}
|
|
_unboundFunctions.Clear();
|
|
return new BoundScript((BoundBlockStatement) bound, e.Span, Scope, fileName, _script);
|
|
}
|
|
|
|
private BoundStatement BindStatement(StatementSyntax s)
|
|
{
|
|
switch (s.Kind)
|
|
{
|
|
case SyntaxKind.ExpressionStatement:
|
|
return BindExpressionStatement((ExpressionStatementSyntax) s);
|
|
case SyntaxKind.AssignmentStatement:
|
|
return BindAssignmentStatement((AssignmentStatementSyntax) s);
|
|
case SyntaxKind.BlockStatement:
|
|
return BindBlockStatement((BlockStatementSyntax) s);
|
|
case SyntaxKind.IfStatement:
|
|
return BindIfStatement((IfStatementSyntax) s);
|
|
case SyntaxKind.ReturnStatement:
|
|
return BindReturnStatement((ReturnStatementSyntax) s);
|
|
case SyntaxKind.FunctionAssignmentStatement:
|
|
return BindFunctionAssignmentStatement((FunctionAssignmentStatementSyntax) s);
|
|
case SyntaxKind.TableAssignmentStatement:
|
|
return BindTableAssignmentStatement((TableAssigmentStatementSyntax) s);
|
|
case SyntaxKind.MultiAssignmentStatement:
|
|
return BindMultiAssignmentStatement((MultiAssignmentStatementSyntax) s);
|
|
case SyntaxKind.NumericForStatement:
|
|
return BindNumericForStatement((NumericForStatementSyntax) s);
|
|
case SyntaxKind.GenericForStatement:
|
|
return BindGenericForStatement((GenericForStatementSyntax) s);
|
|
case SyntaxKind.WhileStatement:
|
|
return BindWhileStatement((WhileStatementSyntax) s);
|
|
case SyntaxKind.YieldStatement:
|
|
return BindYieldStatement((YieldStatementSyntax) s);
|
|
case SyntaxKind.BreakStatement:
|
|
return new BoundBreakStatement(s.Span);
|
|
}
|
|
|
|
throw new NotImplementedException(s.Kind.ToString());
|
|
}
|
|
|
|
private BoundExpression BindExpression(ExpressionSyntax e)
|
|
{
|
|
switch (e.Kind)
|
|
{
|
|
case SyntaxKind.UnaryExpression:
|
|
return BindUnaryExpression((UnaryExpressionSyntax) e);
|
|
case SyntaxKind.BinaryExpression:
|
|
return BindBinaryExpression((BinaryExpressionSyntax) e);
|
|
case SyntaxKind.LiteralExpression:
|
|
return BindLiteralExpression((LiteralExpressionSyntax) e);
|
|
case SyntaxKind.ParenthesizedExpression:
|
|
return BindParenthesizedExpression((ParenthesizedExpressionSyntax) e);
|
|
case SyntaxKind.VariableExpression:
|
|
return BindVariableExpression((VariableExpressionSyntax) e);
|
|
case SyntaxKind.FunctionCallExpression:
|
|
return BindFunctionCallExpression((FunctionCallExpressionSyntax) e);
|
|
case SyntaxKind.TableExpression:
|
|
return BindTableExpression((TableExpressionSyntax) e);
|
|
case SyntaxKind.IndexExpression:
|
|
return BindIndexExpression((IndexExpressionSyntax) e);
|
|
case SyntaxKind.FullStopIndexExpression:
|
|
return BindFullStopIndexExpression((FullStopIndexExpressionSyntax) e);
|
|
case SyntaxKind.FunctionExpression:
|
|
return BindFunctionExpression((FunctionExpressionSyntax) e);
|
|
case SyntaxKind.BadExpression:
|
|
return new BoundBadExpression(e.Span);
|
|
case SyntaxKind.ScriptUnit:
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
throw new NotImplementedException(e.Kind.ToString());
|
|
}
|
|
|
|
private BoundExpression BindUnaryExpression(UnaryExpressionSyntax e)
|
|
{
|
|
var inExp = BindExpression(e.Expression);
|
|
if (inExp.Kind == BoundKind.BoundBadExpression)
|
|
return new BoundBadExpression(e.Span);
|
|
var op = BoundUnaryOperator.Bind(e.Operator.Kind, inExp.ValueType);
|
|
if (op == null)
|
|
{
|
|
_diagnostics.LogUnknownUnaryOperator(e.Span, e.Operator.Kind, inExp.ValueType);
|
|
return inExp;
|
|
}
|
|
|
|
return new BoundUnaryExpression(op, inExp, op.OutType, e.Span);
|
|
}
|
|
|
|
private BoundExpression BindBinaryExpression(BinaryExpressionSyntax e)
|
|
{
|
|
var left = BindExpression(e.Left);
|
|
var right = BindExpression(e.Right);
|
|
if (left.Kind == BoundKind.BoundBadExpression || right.Kind == BoundKind.BoundBadExpression)
|
|
return new BoundBadExpression(e.Span);
|
|
var op = BoundBinaryOperator.Bind(e.Operator.Kind, left.ValueType, right.ValueType);
|
|
if (op == null)
|
|
{
|
|
_diagnostics.LogUnknownBinaryOperator(e.Span, e.Operator.Kind, left.ValueType, right.ValueType);
|
|
return left;
|
|
}
|
|
return new BoundBinaryExpression(op, left, right, op.OutType, e.Span);
|
|
}
|
|
|
|
private BoundExpression BindLiteralExpression(LiteralExpressionSyntax e)
|
|
{
|
|
var value = e.Value;
|
|
ScriptType outValue = null;
|
|
switch (value)
|
|
{
|
|
case double d:
|
|
outValue = new ScriptNumberDouble(d);
|
|
break;
|
|
case long l:
|
|
outValue = new ScriptNumberLong(l);
|
|
break;
|
|
case bool b:
|
|
outValue = new ScriptBoolean(b);
|
|
break;
|
|
case string s:
|
|
outValue = new ScriptString(s);
|
|
break;
|
|
case null:
|
|
outValue = new ScriptNull();
|
|
break;
|
|
|
|
default:
|
|
_diagnostics.LogUnknownType(e.Span);
|
|
break;
|
|
}
|
|
return new BoundLiteralExpression(outValue, e.Span);
|
|
}
|
|
|
|
private BoundExpression BindParenthesizedExpression(ParenthesizedExpressionSyntax e)
|
|
{
|
|
return BindExpression(e.Expression);
|
|
}
|
|
|
|
private BoundExpression BindFunctionCallExpression(FunctionCallExpressionSyntax e)
|
|
{
|
|
var expression = BindExpression(e.Identifier);
|
|
if (expression.ValueType != Type.Function && expression.ValueType != Type.Unknown)
|
|
{
|
|
_diagnostics.LogError($"Unknown function called.", e.Span);
|
|
return new BoundBadExpression(e.Span);
|
|
}
|
|
|
|
var parameters = ImmutableArray.CreateBuilder<BoundExpression>();
|
|
foreach (var expressionSyntax in e.Parameters)
|
|
{
|
|
var bound = BindExpression(expressionSyntax);
|
|
parameters.Add(bound);
|
|
}
|
|
|
|
TypeContainer returnType = Type.Unknown;
|
|
var resolved = ResolveVariable(expression, _diagnostics);
|
|
if (resolved == null)
|
|
{
|
|
_diagnostics.LogError("Can't resolve variable", expression.Span);
|
|
}
|
|
|
|
else if (resolved is FunctionVariableSymbol function)
|
|
{
|
|
if (function is ScriptFunctionVariableSymbol scriptFunction)
|
|
{
|
|
if ((scriptFunction.GetFirstValid(parameters.Select(x => x.ValueType).ToArray()) is ScriptFunctionVariableOption functionOption))
|
|
{
|
|
if (!functionOption.IsBound)
|
|
{
|
|
Scope = new BoundScope(Scope);
|
|
for (var index = 0; index < functionOption.Parameters.Length; index++)
|
|
{
|
|
var functionVariable = functionOption.Parameters[index];
|
|
var callingVariable = parameters[index];
|
|
functionVariable.TypeContainer = callingVariable.ValueType;
|
|
Scope.DefineLocalVariable(functionVariable);
|
|
}
|
|
|
|
UnboundFunctionExpression unbound = null;
|
|
foreach (var functionExpression in _unboundFunctions.Where(x =>
|
|
{
|
|
if (x.Name == function.Name)
|
|
{
|
|
return parameters.Count == functionOption.Parameters.Length;
|
|
}
|
|
|
|
return false;
|
|
}))
|
|
{
|
|
unbound = functionExpression;
|
|
break;
|
|
}
|
|
|
|
if (unbound != null)
|
|
{
|
|
unbound.Block = (BoundBlockStatement) BindBlockStatement(unbound.UnboundBlock);
|
|
|
|
returnType = Scope.ReturnType;
|
|
Scope = Scope.ParentScope;
|
|
functionOption.IsBound = true;
|
|
functionOption.ResultType = returnType;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (string.Equals(function.Name, "require") && parameters.Count > 0)
|
|
{
|
|
var parameter = parameters[0];
|
|
if (parameter is BoundLiteralExpression be && be.Value.Type == Type.String)
|
|
{
|
|
var moduleName = be.Value.ToString();
|
|
var module = _script.Options.ModuleHandler.GetModule(_script, moduleName);
|
|
if (!_script.ModuleDependencies.Contains(moduleName))
|
|
_script.ModuleDependencies.Add(moduleName);
|
|
if (module == null)
|
|
{
|
|
var fullPath = Path.GetFullPath(_script.Options.ScriptLoader.ModulesPath);
|
|
_diagnostics.LogError(
|
|
$"Can't find module '{moduleName}' in folder '{fullPath}'",
|
|
parameter.Span);
|
|
}
|
|
else
|
|
{
|
|
foreach (var moduleVariable in module.Scope.Variables)
|
|
{
|
|
if (moduleVariable.Value.Local)
|
|
continue;
|
|
Scope.AssignToNearest(moduleVariable.Value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (resolved is InternalFunctionVariableSymbol internalFunction)
|
|
{
|
|
returnType = internalFunction.GetResultType(parameters.ToArray());
|
|
}
|
|
}
|
|
|
|
var isValid = function.ValidateParameters(parameters.ToImmutable());
|
|
if (!isValid)
|
|
{
|
|
_diagnostics.LogError(
|
|
$"No valid function with name '{function.Name}' and parameter types {string.Join(", ", parameters.Select(x => $"'{x.ValueType}'"))} found",
|
|
expression.Span);
|
|
}
|
|
}
|
|
else if (resolved is UserDataVariableSymbol udSymbol)
|
|
{
|
|
if (udSymbol.Parent != null )
|
|
{
|
|
if (udSymbol.Parent.Properties.TryGetValue(resolved.Name.ToLowerInvariant(),
|
|
out var ubProperty) && ubProperty is UserDataBoundMethod ubMethod)
|
|
{
|
|
var option = ubMethod.Validate(parameters.ToImmutable());
|
|
if (option == null)
|
|
{
|
|
_diagnostics.LogError(
|
|
$"No valid function with name '{ubMethod.Name}' and parameter types {string.Join(", ", parameters.Select(x => $"'{x.ValueType}'"))} found",
|
|
expression.Span);
|
|
}
|
|
else
|
|
{
|
|
returnType = option.ResultType;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return new BoundFunctionCallExpression(expression, parameters.ToImmutable(), e.Span, returnType);
|
|
}
|
|
|
|
public static VariableSymbol ResolveVariable(BoundExpression expression, Diagnostics diagnostics)
|
|
{
|
|
if (expression.Kind == BoundKind.VariableExpression)
|
|
{
|
|
var variableExpression = (BoundVariableExpression) expression;
|
|
return variableExpression.Variable.VariableSymbol;
|
|
}
|
|
if (expression.Kind == BoundKind.BoundFullstopIndexExpression)
|
|
{
|
|
var fullStopIndexExpression = (BoundFullStopIndexExpression) expression;
|
|
var indexerExpression = fullStopIndexExpression.Expression;
|
|
var indexerVariable = ResolveVariable(indexerExpression, diagnostics);
|
|
if (indexerVariable == null)
|
|
{
|
|
diagnostics?.LogError("Can't resolve variable", expression.Span);
|
|
}
|
|
else if (indexerVariable.TypeContainer == Type.Table)
|
|
{
|
|
return ((TableVariableSymbol)indexerVariable).Variables[fullStopIndexExpression.Index];
|
|
}
|
|
else if (indexerVariable.TypeContainer == Type.UserData)
|
|
{
|
|
var parent =
|
|
(UserDataBoundTypeDefinition) ((UserDataVariableSymbol) indexerVariable).BoundTypeDefinition;
|
|
if (parent.Properties.TryGetValue(fullStopIndexExpression.Index.ToLowerInvariant(),
|
|
out var bDefProperty))
|
|
{
|
|
var boundDef = BoundTypeHandler.GetTypeDefinition(bDefProperty.Type.UserData ?? bDefProperty.ActualType);
|
|
if (boundDef != null)
|
|
{
|
|
return new UserDataVariableSymbol(fullStopIndexExpression.Index, boundDef, true, parent);
|
|
}
|
|
diagnostics?.LogWarning($"Can't resolve type '{bDefProperty.Type}'", fullStopIndexExpression.Span);
|
|
return new VariableSymbol(fullStopIndexExpression.Index, Type.Unknown, true);
|
|
}
|
|
else
|
|
{
|
|
diagnostics?.LogWarning(
|
|
$"Can't resolve property '{fullStopIndexExpression.Index}' on type {parent.Name}",
|
|
fullStopIndexExpression.Span);
|
|
}
|
|
}
|
|
else if (indexerVariable.TypeContainer == Type.Unknown)
|
|
{
|
|
if (indexerVariable is UserDataVariableSymbol funcSymbol)
|
|
{
|
|
var boundProp = funcSymbol.BoundTypeDefinition;
|
|
if (boundProp is UserDataBoundTypeDefinition bProp)
|
|
{
|
|
var property = bProp.Properties[fullStopIndexExpression.Index.ToLowerInvariant()];
|
|
var boundDef = BoundTypeHandler.GetTypeDefinition(property.ActualType);
|
|
return new UserDataVariableSymbol(fullStopIndexExpression.Index, boundDef, true, bProp);
|
|
}
|
|
}
|
|
|
|
return new VariableSymbol(fullStopIndexExpression.Index, Type.Unknown, true);
|
|
}
|
|
}
|
|
else if (expression.Kind == BoundKind.BoundIndexExpression)
|
|
{
|
|
var indexExpression = (BoundIndexExpression) expression;
|
|
var indexerExpression = indexExpression.Identifier;
|
|
var indexerVariable = ResolveVariable(indexerExpression, diagnostics);
|
|
if (indexerVariable == null)
|
|
{
|
|
diagnostics?.LogError("Can't resolve variable", expression.Span);
|
|
}
|
|
else if (indexerVariable.TypeContainer == Type.Table)
|
|
{
|
|
var tableVariable = (TableVariableSymbol)indexerVariable;
|
|
if (indexExpression.Index is BoundLiteralExpression literal)
|
|
{
|
|
if (literal.Value.Type == Type.Number || literal.Value.Type == Type.String)
|
|
{
|
|
var toString = literal.Value.ToString();
|
|
if (!tableVariable.Variables.TryGetValue(toString, out var variable) || variable.Local)
|
|
{
|
|
diagnostics?.LogError($"No variable '{toString}' found in table.", expression.Span);
|
|
return new VariableSymbol("", Type.Nil, true);
|
|
}
|
|
return new VariableSymbol("", variable.TypeContainer, true);
|
|
}
|
|
|
|
}
|
|
if (tableVariable.TypeContainer is CompositeTypeContainer compositeTypeContainer)
|
|
{
|
|
return new VariableSymbol("", compositeTypeContainer.Types[1], true);
|
|
}
|
|
return new VariableSymbol("", expression.ValueType, true);
|
|
}
|
|
else if (indexerVariable.TypeContainer == Type.Unknown)
|
|
{
|
|
return new VariableSymbol("", Type.Unknown, true);
|
|
}
|
|
}
|
|
else if (expression.Kind == BoundKind.BoundFunctionCallExpression)
|
|
{
|
|
if (expression.ValueType == Type.UserData)
|
|
{
|
|
var ud = expression.ValueType.UserData;
|
|
if (!string.IsNullOrEmpty(ud))
|
|
{
|
|
var boundDef = BoundTypeHandler.GetTypeDefinition(ud);
|
|
return new UserDataVariableSymbol("", boundDef, true);
|
|
}
|
|
}
|
|
return new VariableSymbol("", expression.ValueType, true);
|
|
}
|
|
else if (expression.ValueType == Type.Unknown)
|
|
{
|
|
return new VariableSymbol("", Type.Unknown, true);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private BoundExpression BindVariableExpression(VariableExpressionSyntax e)
|
|
{
|
|
var name = e.Identifier.Name;
|
|
if (!Scope.TryGetVariable(name, true, out var variable))
|
|
{
|
|
_diagnostics.LogUnknownVariable(e.Identifier.Span, name);
|
|
return new BoundBadExpression(e.Span);
|
|
}
|
|
var boundVariable = new BoundVariableSymbol(variable, false, e.Identifier.Span);
|
|
return new BoundVariableExpression(boundVariable, e.Span);
|
|
}
|
|
|
|
private BoundExpressionStatement BindExpressionStatement(ExpressionStatementSyntax s)
|
|
{
|
|
var exp = BindExpression(s.Expression);
|
|
return new BoundExpressionStatement(exp, s.Span);
|
|
}
|
|
|
|
private (VariableSymbol Symbol, bool IsCreation) TryBindVariable(string name, bool isLocal, BoundExpression assignment, string[] commentData)
|
|
{
|
|
if (name == "_")
|
|
return (null, false);
|
|
var isCreation = false;
|
|
if (!Scope.TryGetVariable(name, !isLocal, out var variable))
|
|
{
|
|
if (assignment.ValueType == Type.Table)
|
|
{
|
|
if (assignment.Kind == BoundKind.BoundTableExpression)
|
|
{
|
|
variable = new TableVariableSymbol(name, isLocal,
|
|
((BoundTableExpression) assignment).Expressions, assignment.ValueType);
|
|
}
|
|
else if (assignment.Kind == BoundKind.VariableExpression)
|
|
{
|
|
variable = new TableVariableSymbol(name, isLocal,
|
|
((TableVariableSymbol) ((BoundVariableExpression) assignment).Variable.VariableSymbol)
|
|
.Variables, assignment.ValueType);
|
|
}
|
|
else
|
|
{
|
|
variable = new TableVariableSymbol(name, isLocal, assignment.ValueType);
|
|
}
|
|
}
|
|
else if (assignment.ValueType == Type.UserData)
|
|
{
|
|
var ud = assignment.ValueType.UserData;
|
|
if (string.IsNullOrEmpty(ud))
|
|
{
|
|
variable = new VariableSymbol(name, Type.Unknown, isLocal);
|
|
}
|
|
else
|
|
{
|
|
var boundType = BoundTypeHandler.GetTypeDefinition(ud);
|
|
if (boundType != null)
|
|
{
|
|
variable = new UserDataVariableSymbol(name,
|
|
BoundTypeHandler.GetTypeDefinition(ud), isLocal);
|
|
}
|
|
else
|
|
{
|
|
variable = new VariableSymbol(name, assignment.ValueType, isLocal);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
variable = new VariableSymbol(name, assignment.ValueType, isLocal);
|
|
}
|
|
|
|
variable.CommentValue = commentData;
|
|
|
|
if (isLocal)
|
|
Scope.DefineLocalVariable(variable);
|
|
else
|
|
Scope.AssignToNearest(variable);
|
|
|
|
isCreation = true;
|
|
}
|
|
else
|
|
{
|
|
// don't allow assigning different typed variables to a variable, unless either of them is nil, allow assigning nil to all variables
|
|
if (assignment.ValueType != variable.TypeContainer)
|
|
{
|
|
if (variable.TypeContainer == Type.Nil || assignment.ValueType == Type.Nil)
|
|
{
|
|
variable.TypeContainer = assignment.ValueType;
|
|
}
|
|
else if (variable.TypeContainer == Type.Unknown)
|
|
{
|
|
variable.TypeContainer = assignment.ValueType;
|
|
}
|
|
else if (assignment.ValueType == Type.Unknown && assignment is BoundVariableExpression v)
|
|
{
|
|
v.Variable.VariableSymbol.TypeContainer = variable.TypeContainer;
|
|
}
|
|
else if (assignment.ValueType == Type.Unknown)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
_diagnostics.LogCannotConvert(assignment.ValueType, variable.TypeContainer, assignment.Span);
|
|
return (null, false);
|
|
}
|
|
}
|
|
}
|
|
return (variable, isCreation);
|
|
}
|
|
|
|
private BoundStatement BindAssignmentStatement(AssignmentStatementSyntax e)
|
|
{
|
|
if (e.Identifier.Kind == SyntaxKind.VariableExpression)
|
|
{
|
|
var variableExpression = (VariableExpressionSyntax) e.Identifier;
|
|
var name = variableExpression.Identifier.Name;
|
|
var boundExpression = BindExpression(e.Expression);
|
|
|
|
var isLocal = e.LocalToken != null;
|
|
var (symbol, isCreation) = TryBindVariable(name, isLocal, boundExpression, e.CommentData);
|
|
if (symbol != null)
|
|
{
|
|
if (symbol.TypeContainer == Type.Unknown)
|
|
{
|
|
_diagnostics.LogUnknownVariableType(symbol.Name, variableExpression.Span);
|
|
}
|
|
|
|
var variable = new BoundVariableSymbol(symbol, isCreation, variableExpression.Span);
|
|
return new BoundVariableAssignment(variable, boundExpression, isLocal, e.Span);
|
|
}
|
|
}
|
|
|
|
return new BoundExpressionStatement(new BoundBadExpression(e.Span), e.Span);
|
|
}
|
|
|
|
private BoundStatement BindMultiAssignmentStatement(MultiAssignmentStatementSyntax s)
|
|
{
|
|
var ls = new List<VariableSymbol>();
|
|
var assignment = BindExpression(s.Expression);
|
|
var isLocal = s.LocalKeyword != null;
|
|
|
|
foreach (var identifierToken in s.Identifiers)
|
|
{
|
|
var boundVariable = TryBindVariable(identifierToken.Name, isLocal, assignment, null);
|
|
if (boundVariable.Symbol.TypeContainer == Type.Unknown)
|
|
{
|
|
_diagnostics.LogUnknownVariableType(boundVariable.Symbol.Name, identifierToken.Span);
|
|
}
|
|
ls.Add(boundVariable.Symbol);
|
|
}
|
|
return new BoundMultiAssignmentStatement(ls.ToImmutableArray(), assignment, s.Span);
|
|
}
|
|
|
|
private BoundStatement BindBlockStatement(BlockStatementSyntax e)
|
|
{
|
|
var arr = ImmutableArray.CreateBuilder<BoundStatement>();
|
|
foreach (var statementSyntax in e.Statements)
|
|
{
|
|
var bound = BindStatement(statementSyntax);
|
|
arr.Add(bound);
|
|
}
|
|
|
|
return new BoundBlockStatement(arr.ToImmutable(), e.Span);
|
|
}
|
|
|
|
private BoundStatement BindIfStatement(IfStatementSyntax e)
|
|
{
|
|
Scope = new BoundScope(Scope);
|
|
var condition = BindExpressionStatement(e.Condition);
|
|
if (condition.Expression.ValueType != Type.Boolean && condition.Expression.ValueType != Type.Unknown)
|
|
{
|
|
_diagnostics.LogError("Condition for if statement should be a boolean.", condition.Span);
|
|
}
|
|
var block = BindBlockStatement(e.Block);
|
|
Scope = Scope.ParentScope;
|
|
if (e.NextElseIfStatement != null)
|
|
{
|
|
var nextElseIf = BindIfStatement(e.NextElseIfStatement);
|
|
return new BoundIfStatement(condition, (BoundBlockStatement) block,
|
|
(BoundIfStatement) nextElseIf, e.Span);
|
|
}
|
|
if (e.ElseStatement == null)
|
|
{
|
|
return new BoundIfStatement(condition, (BoundBlockStatement) block, e.Span);
|
|
}
|
|
else
|
|
{
|
|
Scope = new BoundScope(Scope);
|
|
var elseBlock = BindBlockStatement(e.ElseStatement.Block);
|
|
var elseStatement = new BoundElseStatement((BoundBlockStatement) elseBlock, e.Span);
|
|
Scope = Scope.ParentScope;
|
|
|
|
return new BoundIfStatement(condition, (BoundBlockStatement) block,
|
|
elseStatement, e.Span);
|
|
}
|
|
}
|
|
|
|
private BoundExpression BindFunctionExpression(FunctionExpressionSyntax e, string functionVariableSymbol = null)
|
|
{
|
|
var innerScope = new BoundScope(Scope);
|
|
var parameters = ImmutableArray.CreateBuilder<BoundVariableSymbol>();
|
|
foreach (var identifierToken in e.Parameters)
|
|
{
|
|
var variable = identifierToken;
|
|
VariableSymbol variableSymbol;
|
|
if (variable.TypeName != null)
|
|
{
|
|
var type = BoundTypeHandler.GetTypeDefinition(variable.TypeName.Name);
|
|
if (type == null)
|
|
{
|
|
_diagnostics.LogError($"Unknown type name '{variable.TypeName.Name}'", variable.Span);
|
|
variableSymbol = new UserDataVariableSymbol(variable.IdentifierName.Name, Type.Unknown, true);
|
|
}
|
|
else if (type.ScriptType == Type.Table)
|
|
{
|
|
variableSymbol = new TableVariableSymbol(variable.IdentifierName.Name, true,
|
|
new CompositeTypeContainer(
|
|
new TypeContainer[] {Type.Unknown, Type.Unknown}.ToImmutableArray()));
|
|
}
|
|
else
|
|
{
|
|
variableSymbol = new UserDataVariableSymbol(variable.IdentifierName.Name, type, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
variableSymbol = new UserDataVariableSymbol(variable.IdentifierName.Name, Type.Unknown, true);
|
|
}
|
|
parameters.Add(new BoundVariableSymbol(variableSymbol, true, identifierToken.Span));
|
|
innerScope.DefineLocalVariable(variableSymbol);
|
|
}
|
|
|
|
if (parameters.All(x => x.ValueType != Type.Unknown))
|
|
{
|
|
Scope = innerScope;
|
|
var block = BindBlockStatement(e.Block);
|
|
var returnType = Scope.ReturnType;
|
|
Scope = Scope.ParentScope;
|
|
var func = new BoundFunctionExpression(parameters.ToImmutable(), (BoundBlockStatement) block, e.Span,
|
|
innerScope, returnType, e.IsCoroutine);
|
|
return func;
|
|
}
|
|
else
|
|
{
|
|
var unbound = new UnboundFunctionExpression(parameters.ToImmutable(), e.Block, e.Span, innerScope,
|
|
functionVariableSymbol, e.IsCoroutine);
|
|
_unboundFunctions.Add(unbound);
|
|
return unbound;
|
|
}
|
|
}
|
|
|
|
private BoundStatement BindFunctionAssignmentStatement(FunctionAssignmentStatementSyntax e)
|
|
{
|
|
var name = e.Identifier.Name;
|
|
var isLocal = e.LocalToken != null;
|
|
var innerScope = new BoundScope(Scope);
|
|
|
|
var func = (BoundFunctionExpression)BindFunctionExpression(e.FunctionExpression, name);
|
|
var parameters = ImmutableArray.CreateBuilder<VariableSymbol>();
|
|
|
|
foreach (var parameter in func.Parameters)
|
|
{
|
|
var vari = new VariableSymbol(parameter.VariableSymbol.Name, parameter.VariableSymbol.TypeContainer, true);
|
|
parameters.Add(vari);
|
|
innerScope.DefineLocalVariable(vari);
|
|
}
|
|
var commentData = new List<string>();
|
|
if (e.CommentData != null)
|
|
{
|
|
commentData.AddRange(e.CommentData);
|
|
}
|
|
|
|
if (!Scope.TryGetVariable(name, !isLocal, out var variable))
|
|
{
|
|
var functionVariable = new ScriptFunctionVariableSymbol(name, isLocal, parameters.ToImmutable(), func.ReturnType
|
|
, func.IsCoroutine)
|
|
{
|
|
CommentValue = commentData.ToArray()
|
|
};
|
|
variable = functionVariable;
|
|
((ScriptFunctionVariableOption)functionVariable.FunctionOption[0]).IsBound = !(func is UnboundFunctionExpression);
|
|
functionVariable.FunctionOption[0].ResultType = func.ReturnType;
|
|
if (isLocal)
|
|
Scope.DefineLocalVariable(variable);
|
|
else
|
|
Scope.AssignToNearest(variable);
|
|
}
|
|
else
|
|
{
|
|
// don't allow assigning different typed variables to a variable, unless either of them is nil, allow assigning nil to all variables
|
|
if (variable.TypeContainer != Type.Function)
|
|
{
|
|
if (variable.TypeContainer == Type.Nil || variable.TypeContainer == Type.Unknown)
|
|
{
|
|
variable.TypeContainer = Type.Function;
|
|
}
|
|
else
|
|
{
|
|
_diagnostics.LogCannotConvert(Type.Function, variable.TypeContainer, e.Span);
|
|
return new BoundExpressionStatement(new BoundBadExpression(e.Span), e.Span);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (variable is ScriptFunctionVariableSymbol functionVariable)
|
|
{
|
|
var functionOption =
|
|
new ScriptFunctionVariableOption(func.ReturnType, parameters.ToImmutable())
|
|
{
|
|
IsBound = !(func is UnboundFunctionExpression)
|
|
};
|
|
functionVariable.FunctionOption.Add(functionOption);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return new BoundFunctionAssignmentStatement(variable, func, e.Span);
|
|
}
|
|
|
|
private BoundStatement BindReturnStatement(ReturnStatementSyntax e)
|
|
{
|
|
if (e.Expression == null)
|
|
return new BoundReturnStatement(null, e.Span);
|
|
|
|
var expression = BindExpression(e.Expression);
|
|
if (expression.ValueType != Type.Unknown && expression.ValueType != Type.Unknown &&
|
|
Scope.ReturnType != Type.Unknown && Scope.ReturnType != Type.Nil)
|
|
{
|
|
if (expression.ValueType != Scope.ReturnType)
|
|
{
|
|
_diagnostics.LogError($"Can't return type '{expression.ValueType}' from this scope, earlier in the" +
|
|
$" scope a return type of '{Scope.ReturnType}' is defined.", e.Span);
|
|
}
|
|
}
|
|
if (expression.ValueType != Type.Unknown && expression.ValueType != Type.Nil)
|
|
Scope.ReturnType = expression.ValueType;
|
|
return new BoundReturnStatement(expression, e.Span);
|
|
}
|
|
|
|
private BoundExpression BindTableExpression(TableExpressionSyntax e)
|
|
{
|
|
var statements = ImmutableArray.CreateBuilder<BoundStatement>();
|
|
var s = Scope;
|
|
Scope = BoundScope.WithReadOnlyScope(s);
|
|
var innerVariables = new Dictionary<string, VariableSymbol>();
|
|
var current = 0;
|
|
|
|
foreach (var expressionSyntax in e.Expressions)
|
|
{
|
|
var bound = BindStatement((StatementSyntax) expressionSyntax);
|
|
if (bound.Kind == BoundKind.BoundExpressionStatement)
|
|
{
|
|
var boundExpression = (BoundExpressionStatement)bound;
|
|
current++;
|
|
innerVariables.Add(current.ToString(),
|
|
new VariableSymbol(current.ToString(), boundExpression.Expression.ValueType, false));
|
|
}
|
|
statements.Add(bound);
|
|
}
|
|
|
|
innerVariables = innerVariables.Union(Scope.Variables).ToDictionary(k => k.Key, v => v.Value);
|
|
var innerSCope = Scope;
|
|
Scope = s;
|
|
return new BoundTableExpression(innerVariables, statements.ToImmutable(), e.Span, innerSCope);
|
|
}
|
|
|
|
private BoundExpression BindIndexExpression(IndexExpressionSyntax e, bool isAssignment = false)
|
|
{
|
|
var expression = BindExpression(e.Expression);
|
|
|
|
var index = BindExpression(e.Index);
|
|
switch (expression.ValueType.Type)
|
|
{
|
|
case Type.Table:
|
|
if (isAssignment)
|
|
{
|
|
return new BoundIndexExpression(expression, index, Type.Unknown, e.Span);
|
|
}
|
|
if (expression.Kind == BoundKind.BoundTableExpression && index.Kind == BoundKind.BoundLiteralExpression)
|
|
{
|
|
var table = (BoundTableExpression)expression;
|
|
var realIndex = (BoundLiteralExpression) index;
|
|
var variableDic = table.Expressions;
|
|
if (variableDic.TryGetValue(realIndex.Value.ToString(), out var variable) && !variable.Local)
|
|
{
|
|
return new BoundIndexExpression(expression, index, variable.TypeContainer, e.Span);
|
|
}
|
|
|
|
_diagnostics.LogError($"No variable '{realIndex.Value}' found in table.",
|
|
e.Span);
|
|
}
|
|
else if (expression.Kind == BoundKind.VariableExpression &&
|
|
index.Kind == BoundKind.BoundLiteralExpression)
|
|
{
|
|
var table = (BoundVariableExpression)expression;
|
|
var realTable = table.Variable;
|
|
var realIndex = (BoundLiteralExpression) index;
|
|
var tableSymbol = ((TableVariableSymbol) realTable.VariableSymbol);
|
|
if (!tableSymbol.ContentAware)
|
|
{
|
|
return new BoundIndexExpression(expression, index, Type.Unknown, e.Span);
|
|
}
|
|
var variableDic = tableSymbol.Variables;
|
|
if (variableDic.TryGetValue(realIndex.Value.ToString(), out var variable) && !variable.Local)
|
|
{
|
|
return new BoundIndexExpression(expression, index, variable.TypeContainer, e.Span);
|
|
}
|
|
|
|
_diagnostics.LogError($"No variable '{realIndex.Value}' found in table '{realTable.VariableSymbol.Name}'.",
|
|
e.Span);
|
|
}
|
|
else if (expression.ValueType is CompositeTypeContainer compositeTypeContainer)
|
|
{
|
|
return new BoundIndexExpression(expression, index, compositeTypeContainer.Types[1], e.Span);
|
|
}
|
|
return new BoundIndexExpression(expression, index, Type.Unknown, e.Span);
|
|
case Type.UserData:
|
|
case Type.Unknown:
|
|
return new BoundIndexExpression(expression, index, Type.Unknown, e.Span);
|
|
case Type.String when index.ValueType == Type.Number:
|
|
return new BoundIndexExpression(expression, index, Type.String, e.Span);
|
|
default:
|
|
_diagnostics.LogInvalidIndexExpression(expression.ValueType, index.ValueType, e.Span);
|
|
return new BoundBadExpression(e.Span);
|
|
}
|
|
}
|
|
|
|
private BoundExpression BindFullStopIndexExpression(FullStopIndexExpressionSyntax e, bool isAssignment = false)
|
|
{
|
|
var expression = BindExpression(e.Expression);
|
|
var index = e.Index.Name;
|
|
switch (expression.ValueType.Type)
|
|
{
|
|
case Type.Table:
|
|
if (isAssignment)
|
|
{
|
|
return new BoundFullStopIndexExpression(expression, index, Type.Unknown, e.Span);
|
|
}
|
|
if (expression.Kind == BoundKind.BoundTableExpression)
|
|
{
|
|
var table = (BoundTableExpression)expression;
|
|
if (table.Expressions.TryGetValue(index, out var variable) && !variable.Local)
|
|
{
|
|
return new BoundFullStopIndexExpression(expression, index, variable.TypeContainer, e.Span);
|
|
}
|
|
_diagnostics.LogError($"No variable '{index}' found in table.", e.Span);
|
|
}
|
|
if (expression.Kind == BoundKind.VariableExpression)
|
|
{
|
|
var table = (BoundVariableExpression)expression;
|
|
var realTable = table.Variable;
|
|
var variableDic = ((TableVariableSymbol) realTable.VariableSymbol).Variables;
|
|
if (variableDic.TryGetValue(index, out var variable) && !variable.Local)
|
|
{
|
|
return new BoundFullStopIndexExpression(expression, index, variable.TypeContainer, e.Span);
|
|
}
|
|
|
|
_diagnostics.LogError($"No variable '{index}' found in table '{realTable.VariableSymbol.Name}'.",
|
|
e.Span);
|
|
}
|
|
return new BoundFullStopIndexExpression(expression, index, Type.Unknown, e.Span);
|
|
case Type.UserData:
|
|
if (isAssignment)
|
|
{
|
|
return new BoundFullStopIndexExpression(expression, index, Type.Unknown, e.Span);
|
|
}
|
|
|
|
var variableSymbol = ResolveVariable(expression, _diagnostics);
|
|
if (variableSymbol == null)
|
|
{
|
|
_diagnostics.LogError("Can't resolve variable", expression.Span);
|
|
}
|
|
else
|
|
{
|
|
if (variableSymbol is UserDataVariableSymbol functionParameter)
|
|
{
|
|
var udBoundDef = (UserDataBoundTypeDefinition)functionParameter.BoundTypeDefinition;
|
|
if (udBoundDef.Properties.TryGetValue(index.ToLowerInvariant(), out var property))
|
|
{
|
|
return new BoundFullStopIndexExpression(expression, index, property.Type, e.Span);
|
|
}
|
|
_diagnostics.LogError($"No variable '{index}' found on type '{udBoundDef.Name}'.",
|
|
e.Span);
|
|
}
|
|
}
|
|
return new BoundFullStopIndexExpression(expression, index, Type.Unknown, e.Span);
|
|
case Type.Unknown:
|
|
return new BoundFullStopIndexExpression(expression, index, Type.Unknown, e.Span);
|
|
case Type.String:
|
|
return new BoundFullStopIndexExpression(expression, index, Type.String, e.Span);
|
|
default:
|
|
_diagnostics.LogInvalidIndexExpression(expression.ValueType, Type.String, e.Span);
|
|
return new BoundBadExpression(e.Span);
|
|
}
|
|
}
|
|
|
|
private BoundStatement BindTableAssignmentStatement(TableAssigmentStatementSyntax e)
|
|
{
|
|
BoundExpression indexableExpression;
|
|
var value = BindExpression(e.Expression);
|
|
if (e.TableExpression.Kind == SyntaxKind.BadExpression)
|
|
return new BoundExpressionStatement(new BoundBadExpression(e.Span), e.Span);
|
|
|
|
if (e.TableExpression.Kind == SyntaxKind.IndexExpression)
|
|
{
|
|
var idExp = BindIndexExpression((IndexExpressionSyntax) e.TableExpression, true);
|
|
if (idExp is BoundBadExpression)
|
|
return new BoundExpressionStatement(new BoundBadExpression(e.Span), e.Span);
|
|
var indexable = (BoundIndexExpression) idExp;
|
|
|
|
if (indexable.Identifier.Kind == BoundKind.VariableExpression &&
|
|
indexable.Index.Kind == BoundKind.BoundLiteralExpression)
|
|
{
|
|
var variable = (BoundVariableExpression)indexable.Identifier;
|
|
var index = (BoundLiteralExpression)indexable.Index;
|
|
var variableSymbol = variable.Variable.VariableSymbol;
|
|
if (variableSymbol is TableVariableSymbol tableVariableSymbol)
|
|
{
|
|
tableVariableSymbol.Variables.Add(index.Value.ToString(),
|
|
new VariableSymbol(index.Value.ToString(), value.ValueType, false));
|
|
}
|
|
}
|
|
indexableExpression = indexable;
|
|
}
|
|
else
|
|
{
|
|
var indexableExp = BindFullStopIndexExpression(
|
|
(FullStopIndexExpressionSyntax) e.TableExpression, true);
|
|
if (!(indexableExp is BoundFullStopIndexExpression indexable))
|
|
return new BoundExpressionStatement(new BoundBadExpression(e.Span), e.Span);
|
|
|
|
if (indexable.Expression.Kind == BoundKind.VariableExpression)
|
|
{
|
|
var variable = (BoundVariableExpression)indexable.Expression;
|
|
if (variable.ValueType == Type.Table)
|
|
{
|
|
((TableVariableSymbol)variable.Variable.VariableSymbol).Variables.Add(indexable.Index,
|
|
new VariableSymbol(indexable.Index, value.ValueType, false));
|
|
}
|
|
}
|
|
indexableExpression = indexable;
|
|
}
|
|
|
|
return new BoundTableAssigmentStatement(indexableExpression, value, e.Span);
|
|
}
|
|
|
|
private BoundStatement BindNumericForStatement(NumericForStatementSyntax e)
|
|
{
|
|
var variableName = e.Identifier.Name;
|
|
Scope = new BoundScope(Scope);
|
|
var variable = new VariableSymbol(variableName, Type.Number, true);
|
|
Scope.DefineLocalVariable(variable);
|
|
var boundStart = BindExpression(e.StartExpression);
|
|
var boundStop = BindExpression(e.StopExpression);
|
|
BoundExpression boundStep = null;
|
|
if (e.StepExpression != null)
|
|
boundStep = BindExpression(e.StepExpression);
|
|
var block = BindBlockStatement((BlockStatementSyntax) e.Block);
|
|
Scope = Scope.ParentScope;
|
|
return new BoundNumericForStatement(variable, boundStart, boundStop, boundStep, (BoundBlockStatement) block,
|
|
e.Span);
|
|
}
|
|
|
|
private BoundStatement BindGenericForStatement(GenericForStatementSyntax e)
|
|
{
|
|
Scope = new BoundScope(Scope);
|
|
var array = ImmutableArray.CreateBuilder<BoundVariableSymbol>();
|
|
|
|
var keyVar = e.Variables[0];
|
|
var keyVariable = new VariableSymbol(keyVar.Name, Type.String, true);
|
|
Scope.DefineLocalVariable(keyVariable);
|
|
array.Add(new BoundVariableSymbol(keyVariable, true, keyVar.Span));
|
|
|
|
var boundEnumerableExpression = BindExpression(e.EnumerableExpression);
|
|
|
|
var valueVar = e.Variables[1];
|
|
VariableSymbol valueVariable;
|
|
if (boundEnumerableExpression.ValueType is CompositeTypeContainer composite && composite.Types.Length == 2)
|
|
{
|
|
var keyType = composite.Types[0];
|
|
keyVariable.TypeContainer = keyType;
|
|
|
|
var type = composite.Types[1];
|
|
if (type == Type.UserData)
|
|
{
|
|
var ud = type.UserData;
|
|
if (ud == null)
|
|
{
|
|
valueVariable = new VariableSymbol(valueVar.Name, Type.Unknown, true);
|
|
}
|
|
else
|
|
{
|
|
valueVariable = new UserDataVariableSymbol(valueVar.Name,
|
|
BoundTypeHandler.GetTypeDefinition(type.UserData), true);
|
|
}
|
|
}
|
|
else if (type == Type.Table)
|
|
{
|
|
valueVariable = new TableVariableSymbol(valueVar.Name, true, composite.Types[1]);
|
|
}
|
|
else
|
|
{
|
|
valueVariable = new VariableSymbol(valueVar.Name, composite.Types[1], true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
valueVariable = new VariableSymbol(valueVar.Name, Type.Unknown, true);
|
|
}
|
|
Scope.DefineLocalVariable(valueVariable);
|
|
array.Add(new BoundVariableSymbol(valueVariable, true, valueVar.Span));
|
|
|
|
|
|
var block = BindBlockStatement(e.Block);
|
|
|
|
return new BoundGenericForStatement(array.ToImmutable(), boundEnumerableExpression, block, e.Span);
|
|
}
|
|
|
|
private BoundStatement BindWhileStatement(WhileStatementSyntax e)
|
|
{
|
|
Scope = new BoundScope(Scope);
|
|
var condition = BindExpression(e.Expression);
|
|
var block = BindBlockStatement((BlockStatementSyntax) e.Block);
|
|
|
|
return new BoundWhileStatement(condition, block, e.Span);
|
|
}
|
|
|
|
private BoundYieldStatement BindYieldStatement(YieldStatementSyntax yieldStatementSyntax)
|
|
{
|
|
var expression = BindExpression(yieldStatementSyntax.Expression);
|
|
return new BoundYieldStatement(expression, yieldStatementSyntax.Span);
|
|
}
|
|
}
|
|
} |