private bool TryAdaptVariableDeclarator(JassMapScriptAdapterContext context, bool isGlobalVariable, IVariableDeclaratorSyntax declarator, [NotNullWhen(true)] out IVariableDeclaratorSyntax?adaptedDeclarator)
{
if (!context.KnownTypes.ContainsKey(declarator.Type.TypeName.Name))
{
context.Diagnostics.Add($"Unknown variable type '{declarator.Type}'.");
}
if (isGlobalVariable)
{
if (!context.KnownGlobalVariables.TryAdd(declarator.IdentifierName.Name, declarator.Type.TypeName.Name))
{
context.Diagnostics.Add($"Duplicate global variable '{declarator.IdentifierName}'.");
}
}
else
{
if (!context.KnownLocalVariables.TryAdd(declarator.IdentifierName.Name, declarator.Type.TypeName.Name))
{
context.Diagnostics.Add($"Duplicate local variable '{declarator.IdentifierName}'.");
}
}
return(declarator switch
{
JassArrayDeclaratorSyntax arrayDeclarator => TryAdaptArrayDeclarator(context, isGlobalVariable, arrayDeclarator, out adaptedDeclarator),
JassVariableDeclaratorSyntax variableDeclarator => TryAdaptVariableDeclarator(context, isGlobalVariable, variableDeclarator, out adaptedDeclarator),
_ => TryAdaptDummy(context, declarator, out adaptedDeclarator),
});
private bool TryAdaptArgumentList(JassMapScriptAdapterContext context, JassArgumentListSyntax argumentList, [NotNullWhen(true)] out JassArgumentListSyntax?adaptedArgumentList)
{
var isAdapted = false;
var argumentsBuilder = ImmutableArray.CreateBuilder <IExpressionSyntax>();
foreach (var argument in argumentList.Arguments)
{
if (TryAdaptExpression(context, argument, out var adaptedArgument))
{
argumentsBuilder.Add(adaptedArgument);
isAdapted = true;
}
else
{
argumentsBuilder.Add(argument);
}
}
if (isAdapted)
{
adaptedArgumentList = new JassArgumentListSyntax(argumentsBuilder.ToImmutable());
return(true);
}
adaptedArgumentList = null;
return(false);
}
public bool TryAdaptCompilationUnit(JassMapScriptAdapterContext context, JassCompilationUnitSyntax compilationUnit, [NotNullWhen(true)] out JassCompilationUnitSyntax?adaptedCompilationUnit)
{
if (compilationUnit is null)
{
throw new ArgumentNullException(nameof(compilationUnit));
}
var isAdapted = false;
var declarationsBuilder = ImmutableArray.CreateBuilder <ITopLevelDeclarationSyntax>();
foreach (var declaration in compilationUnit.Declarations)
{
if (TryAdaptDeclaration(context, declaration, out var adaptedDeclaration))
{
declarationsBuilder.Add(adaptedDeclaration);
isAdapted = true;
}
else
{
declarationsBuilder.Add(declaration);
}
}
if (isAdapted)
{
adaptedCompilationUnit = new JassCompilationUnitSyntax(declarationsBuilder.ToImmutable());
return(true);
}
adaptedCompilationUnit = null;
return(false);
}
private bool TryAdaptFunctionDeclaration(JassMapScriptAdapterContext context, JassFunctionDeclarationSyntax functionDeclaration, [NotNullWhen(true)] out ITopLevelDeclarationSyntax?adaptedFunctionDeclaration)
{
foreach (var parameter in functionDeclaration.FunctionDeclarator.ParameterList.Parameters)
{
if (!context.KnownTypes.ContainsKey(parameter.Type.TypeName.Name))
{
context.Diagnostics.Add($"Unknown variable type '{parameter.Type}'.");
}
if (!context.KnownLocalVariables.TryAdd(parameter.IdentifierName.Name, parameter.Type.TypeName.Name))
{
context.Diagnostics.Add($"Duplicate local variable '{parameter.IdentifierName}'.");
}
}
if (TryAdaptFunctionDeclarator(context, functionDeclaration.FunctionDeclarator, out var adaptedFunctionDeclarator) |
TryAdaptStatementList(context, functionDeclaration.Body, out var adaptedBody))
{
context.KnownLocalVariables.Clear();
adaptedFunctionDeclaration = new JassFunctionDeclarationSyntax(
adaptedFunctionDeclarator ?? functionDeclaration.FunctionDeclarator,
adaptedBody ?? functionDeclaration.Body);
return(true);
}
context.KnownLocalVariables.Clear();
adaptedFunctionDeclaration = null;
return(false);
}
private bool TryAdaptStatementList(JassMapScriptAdapterContext context, JassStatementListSyntax statementList, [NotNullWhen(true)] out JassStatementListSyntax?adaptedStatementList)
{
var isAdapted = false;
var statementsBuilder = ImmutableArray.CreateBuilder <IStatementSyntax>();
foreach (var statement in statementList.Statements)
{
if (TryAdaptStatement(context, statement, out var adaptedStatement))
{
statementsBuilder.Add(adaptedStatement);
isAdapted = true;
}
else
{
statementsBuilder.Add(statement);
}
}
if (isAdapted)
{
adaptedStatementList = new JassStatementListSyntax(statementsBuilder.ToImmutable());
return(true);
}
adaptedStatementList = null;
return(false);
}
private bool TryAdaptGlobalDeclarationList(JassMapScriptAdapterContext context, JassGlobalDeclarationListSyntax globalDeclarationList, [NotNullWhen(true)] out ITopLevelDeclarationSyntax?adaptedGlobalDeclarationList)
{
var isAdapted = false;
var declarationsBuilder = ImmutableArray.CreateBuilder <IGlobalDeclarationSyntax>();
foreach (var declaration in globalDeclarationList.Globals)
{
if (TryAdaptIGlobalDeclaration(context, declaration, out var adaptedDeclaration))
{
declarationsBuilder.Add(adaptedDeclaration);
isAdapted = true;
}
else
{
declarationsBuilder.Add(declaration);
}
}
if (isAdapted)
{
adaptedGlobalDeclarationList = new JassGlobalDeclarationListSyntax(declarationsBuilder.ToImmutable());
return(true);
}
adaptedGlobalDeclarationList = null;
return(false);
}
private bool TryAdaptIGlobalDeclaration(JassMapScriptAdapterContext context, IGlobalDeclarationSyntax declaration, [NotNullWhen(true)] out IGlobalDeclarationSyntax?adaptedGlobalDeclaration)
{
return(declaration switch
{
JassGlobalDeclarationSyntax globalDeclaration => TryAdaptGlobalDeclaration(context, globalDeclaration, out adaptedGlobalDeclaration),
_ => TryAdaptDummy(context, declaration, out adaptedGlobalDeclaration),
});
private bool TryAdaptVariableReferenceExpression(JassMapScriptAdapterContext context, JassVariableReferenceExpressionSyntax variableReferenceExpression, [NotNullWhen(true)] out IExpressionSyntax?adaptedVariableReferenceExpression)
{
if (!context.KnownLocalVariables.ContainsKey(variableReferenceExpression.IdentifierName.Name) &&
!context.KnownGlobalVariables.ContainsKey(variableReferenceExpression.IdentifierName.Name))
{
context.Diagnostics.Add($"Unknown variable '{variableReferenceExpression.IdentifierName}'.");
}
adaptedVariableReferenceExpression = null;
return(false);
}
private bool TryAdaptNativeFunctionDeclaration(JassMapScriptAdapterContext context, JassNativeFunctionDeclarationSyntax nativeFunctionDeclaration, [NotNullWhen(true)] out ITopLevelDeclarationSyntax?adaptedNativeFunctionDeclaration)
{
if (TryAdaptFunctionDeclarator(context, nativeFunctionDeclaration.FunctionDeclarator, out var adaptedFunctionDeclarator))
{
adaptedNativeFunctionDeclaration = new JassNativeFunctionDeclarationSyntax(adaptedFunctionDeclarator);
return(true);
}
adaptedNativeFunctionDeclaration = null;
return(false);
}
private bool TryAdaptExitStatement(JassMapScriptAdapterContext context, JassExitStatementSyntax exitStatement, [NotNullWhen(true)] out IStatementSyntax?adaptedExitStatement)
{
if (TryAdaptExpression(context, exitStatement.Condition, out var adaptedCondition))
{
adaptedExitStatement = new JassExitStatementSyntax(adaptedCondition);
return(true);
}
adaptedExitStatement = null;
return(false);
}
private bool TryAdaptLoopStatement(JassMapScriptAdapterContext context, JassLoopStatementSyntax loopStatement, [NotNullWhen(true)] out IStatementSyntax?adaptedLoopStatement)
{
if (TryAdaptStatementList(context, loopStatement.Body, out var adaptedBody))
{
adaptedLoopStatement = new JassLoopStatementSyntax(adaptedBody);
return(true);
}
adaptedLoopStatement = null;
return(false);
}
private bool TryAdaptReturnStatement(JassMapScriptAdapterContext context, JassReturnStatementSyntax returnStatement, [NotNullWhen(true)] out IStatementSyntax?adaptedReturnStatement)
{
if (TryAdaptExpression(context, returnStatement.Value, out var adaptedValue))
{
adaptedReturnStatement = new JassReturnStatementSyntax(adaptedValue);
return(true);
}
adaptedReturnStatement = null;
return(false);
}
private bool TryAdaptParenthesizedExpression(JassMapScriptAdapterContext context, JassParenthesizedExpressionSyntax parenthesizedExpression, [NotNullWhen(true)] out IExpressionSyntax?adaptedParenthesizedExpression)
{
if (TryAdaptExpression(context, parenthesizedExpression.Expression, out var adaptedExpression))
{
adaptedParenthesizedExpression = new JassParenthesizedExpressionSyntax(adaptedExpression);
return(true);
}
adaptedParenthesizedExpression = null;
return(false);
}
private bool TryAdaptDeclaration(JassMapScriptAdapterContext context, ITopLevelDeclarationSyntax declaration, [NotNullWhen(true)] out ITopLevelDeclarationSyntax?adaptedDeclaration)
{
return(declaration switch
{
JassGlobalDeclarationListSyntax globalDeclarationList => TryAdaptGlobalDeclarationList(context, globalDeclarationList, out adaptedDeclaration),
JassNativeFunctionDeclarationSyntax nativeFunctionDeclaration => TryAdaptNativeFunctionDeclaration(context, nativeFunctionDeclaration, out adaptedDeclaration),
JassFunctionDeclarationSyntax functionDeclaration => TryAdaptFunctionDeclaration(context, functionDeclaration, out adaptedDeclaration),
JassTypeDeclarationSyntax typeDeclaration => TryAdaptTypeDeclaration(context, typeDeclaration, out adaptedDeclaration),
_ => TryAdaptDummy(context, declaration, out adaptedDeclaration),
});
private bool TryAdaptDebugStatement(JassMapScriptAdapterContext context, JassDebugStatementSyntax debugStatement, [NotNullWhen(true)] out IStatementSyntax?adaptedDebugStatement)
{
if (TryAdaptStatement(context, debugStatement.Statement, out var adaptedStatement))
{
adaptedDebugStatement = new JassDebugStatementSyntax(adaptedStatement);
return(true);
}
adaptedDebugStatement = null;
return(false);
}
private bool TryAdaptLocalVariableDeclarationStatement(JassMapScriptAdapterContext context, JassLocalVariableDeclarationStatementSyntax localVariableDeclarationStatement, [NotNullWhen(true)] out IStatementSyntax?adaptedLocalVariableDeclarationStatement)
{
if (TryAdaptVariableDeclarator(context, false, localVariableDeclarationStatement.Declarator, out var adaptedDeclarator))
{
adaptedLocalVariableDeclarationStatement = new JassLocalVariableDeclarationStatementSyntax(adaptedDeclarator);
return(true);
}
adaptedLocalVariableDeclarationStatement = null;
return(false);
}
private bool TryAdaptTypeDeclaration(JassMapScriptAdapterContext context, JassTypeDeclarationSyntax typeDeclaration, [NotNullWhen(true)] out ITopLevelDeclarationSyntax?adaptedTypeDeclaration)
{
if (!context.KnownTypes.ContainsKey(typeDeclaration.BaseType.TypeName.Name))
{
context.Diagnostics.Add($"Unknown base type '{typeDeclaration.BaseType}'.");
}
context.KnownTypes.Add(typeDeclaration.IdentifierName.Name, typeDeclaration.BaseType.TypeName.Name);
adaptedTypeDeclaration = null;
return(false);
}
private bool TryAdaptElseClause(JassMapScriptAdapterContext context, JassElseClauseSyntax?elseClause, [NotNullWhen(true)] out JassElseClauseSyntax?adaptedElseClause)
{
if (elseClause is not null &&
TryAdaptStatementList(context, elseClause.Body, out var adaptedBody))
{
adaptedElseClause = new JassElseClauseSyntax(adaptedBody);
return(true);
}
adaptedElseClause = null;
return(false);
}
private bool TryAdaptFunctionDeclarator(JassMapScriptAdapterContext context, JassFunctionDeclaratorSyntax functionDeclarator, [NotNullWhen(true)] out JassFunctionDeclaratorSyntax?adaptedFunctionDeclarator)
{
if (!context.KnownFunctions.TryAdd(
functionDeclarator.IdentifierName.Name,
functionDeclarator.ParameterList.Parameters.Select(parameter => parameter.Type.TypeName.Name).ToArray()))
{
context.Diagnostics.Add($"Duplicate function '{functionDeclarator.IdentifierName}'.");
}
adaptedFunctionDeclarator = null;
return(false);
}
private bool TryAdaptEqualsValueClause(JassMapScriptAdapterContext context, JassEqualsValueClauseSyntax?equalsValueClause, [NotNullWhen(true)] out JassEqualsValueClauseSyntax?adaptedEqualsValueClause)
{
if (equalsValueClause is not null &&
TryAdaptExpression(context, equalsValueClause.Expression, out var adaptedExpression))
{
adaptedEqualsValueClause = new JassEqualsValueClauseSyntax(adaptedExpression);
return(true);
}
adaptedEqualsValueClause = null;
return(false);
}
private bool TryAdaptUnaryExpression(JassMapScriptAdapterContext context, JassUnaryExpressionSyntax unaryExpression, [NotNullWhen(true)] out IExpressionSyntax? adaptedUnaryExpression)
{
if (TryAdaptExpression(context, unaryExpression.Expression, out var adaptedExpression))
{
adaptedUnaryExpression = new JassUnaryExpressionSyntax(
unaryExpression.Operator,
adaptedExpression);
return true;
}
adaptedUnaryExpression = null;
return false;
}
private bool TryAdaptExpression(JassMapScriptAdapterContext context, IExpressionSyntax?expression, [NotNullWhen(true)] out IExpressionSyntax?adaptedExpression)
{
return(expression switch
{
JassFunctionReferenceExpressionSyntax functionReferenceExpression => TryAdaptFunctionReferenceExpression(context, functionReferenceExpression, out adaptedExpression),
JassInvocationExpressionSyntax invocationExpression => TryAdaptInvocationExpression(context, invocationExpression, out adaptedExpression),
JassArrayReferenceExpressionSyntax arrayReferenceExpression => TryAdaptArrayReferenceExpression(context, arrayReferenceExpression, out adaptedExpression),
JassVariableReferenceExpressionSyntax variableReferenceExpression => TryAdaptVariableReferenceExpression(context, variableReferenceExpression, out adaptedExpression),
JassParenthesizedExpressionSyntax parenthesizedExpression => TryAdaptParenthesizedExpression(context, parenthesizedExpression, out adaptedExpression),
JassUnaryExpressionSyntax unaryExpression => TryAdaptUnaryExpression(context, unaryExpression, out adaptedExpression),
JassBinaryExpressionSyntax binaryExpression => TryAdaptBinaryExpression(context, binaryExpression, out adaptedExpression),
_ => TryAdaptDummy(context, expression, out adaptedExpression),
});
private bool TryAdaptStatement(JassMapScriptAdapterContext context, IStatementSyntax statement, [NotNullWhen(true)] out IStatementSyntax?adaptedStatement)
{
return(statement switch
{
JassLocalVariableDeclarationStatementSyntax localVariableDeclarationStatement => TryAdaptLocalVariableDeclarationStatement(context, localVariableDeclarationStatement, out adaptedStatement),
JassSetStatementSyntax setStatement => TryAdaptSetStatement(context, setStatement, out adaptedStatement),
JassCallStatementSyntax callStatement => TryAdaptCallStatement(context, callStatement, out adaptedStatement),
JassIfStatementSyntax ifStatement => TryAdaptIfStatement(context, ifStatement, out adaptedStatement),
JassLoopStatementSyntax loopStatement => TryAdaptLoopStatement(context, loopStatement, out adaptedStatement),
JassExitStatementSyntax exitStatement => TryAdaptExitStatement(context, exitStatement, out adaptedStatement),
JassReturnStatementSyntax returnStatement => TryAdaptReturnStatement(context, returnStatement, out adaptedStatement),
JassDebugStatementSyntax debugStatement => TryAdaptDebugStatement(context, debugStatement, out adaptedStatement),
_ => TryAdaptDummy(context, statement, out adaptedStatement),
});
private bool TryAdaptElseIfClause(JassMapScriptAdapterContext context, JassElseIfClauseSyntax elseIfClause, [NotNullWhen(true)] out JassElseIfClauseSyntax?adaptedElseIfClause)
{
if (TryAdaptExpression(context, elseIfClause.Condition, out var adaptedCondition) |
TryAdaptStatementList(context, elseIfClause.Body, out var adaptedBody))
{
adaptedElseIfClause = new JassElseIfClauseSyntax(
adaptedCondition ?? elseIfClause.Condition,
adaptedBody ?? elseIfClause.Body);
return(true);
}
adaptedElseIfClause = null;
return(false);
}
private bool TryAdaptBinaryExpression(JassMapScriptAdapterContext context, JassBinaryExpressionSyntax binaryExpression, [NotNullWhen(true)] out IExpressionSyntax?adaptedBinaryExpression)
{
if (TryAdaptExpression(context, binaryExpression.Left, out var adaptedLeftExpression) |
TryAdaptExpression(context, binaryExpression.Right, out var adaptedRightExpression))
{
adaptedBinaryExpression = new JassBinaryExpressionSyntax(
binaryExpression.Operator,
adaptedLeftExpression ?? binaryExpression.Left,
adaptedRightExpression ?? binaryExpression.Right);
return(true);
}
adaptedBinaryExpression = null;
return(false);
}
private bool TryAdaptFunctionReferenceExpression(JassMapScriptAdapterContext context, JassFunctionReferenceExpressionSyntax functionReferenceExpression, [NotNullWhen(true)] out IExpressionSyntax?adaptedFunctionReferenceExpression)
{
if (context.KnownFunctions.TryGetValue(functionReferenceExpression.IdentifierName.Name, out var knownFunctionParameters))
{
if (knownFunctionParameters.Length != 0)
{
context.Diagnostics.Add($"Invalid function reference: '{functionReferenceExpression.IdentifierName}' should not have any parameters.");
}
}
else
{
context.Diagnostics.Add($"Unknown function '{functionReferenceExpression.IdentifierName}'.");
}
adaptedFunctionReferenceExpression = null;
return(false);
}
private bool TryAdaptArrayReferenceExpression(JassMapScriptAdapterContext context, JassArrayReferenceExpressionSyntax arrayReferenceExpression, [NotNullWhen(true)] out IExpressionSyntax?adaptedArrayReferenceExpression)
{
if (!context.KnownLocalVariables.ContainsKey(arrayReferenceExpression.IdentifierName.Name) &&
!context.KnownGlobalVariables.ContainsKey(arrayReferenceExpression.IdentifierName.Name))
{
context.Diagnostics.Add($"Unknown array '{arrayReferenceExpression.IdentifierName}'.");
}
if (TryAdaptExpression(context, arrayReferenceExpression.Indexer, out var adaptedIndexer))
{
adaptedArrayReferenceExpression = new JassArrayReferenceExpressionSyntax(
arrayReferenceExpression.IdentifierName,
adaptedIndexer);
return(true);
}
adaptedArrayReferenceExpression = null;
return(false);
}
private bool TryAdaptSetStatement(JassMapScriptAdapterContext context, JassSetStatementSyntax setStatement, [NotNullWhen(true)] out IStatementSyntax?adaptedSetStatement)
{
if (!context.KnownLocalVariables.ContainsKey(setStatement.IdentifierName.Name) &&
!context.KnownGlobalVariables.ContainsKey(setStatement.IdentifierName.Name))
{
context.Diagnostics.Add($"Unknown variable '{setStatement.IdentifierName}'.");
}
if (TryAdaptExpression(context, setStatement.Indexer, out var adaptedIndexer) |
TryAdaptEqualsValueClause(context, setStatement.Value, out var adaptedValue))
{
adaptedSetStatement = new JassSetStatementSyntax(
setStatement.IdentifierName,
adaptedIndexer ?? setStatement.Indexer,
adaptedValue ?? setStatement.Value);
return(true);
}
adaptedSetStatement = null;
return(false);
}
private bool TryAdaptCallStatement(JassMapScriptAdapterContext context, JassCallStatementSyntax callStatement, [NotNullWhen(true)] out IStatementSyntax?adaptedCallStatement)
{
if (TryAdaptInvocation(context, callStatement, out var adaptedInvocationName, out var adaptedInvocationArguments))
{
if (string.IsNullOrEmpty(adaptedInvocationName))
{
adaptedCallStatement = new JassCommentSyntax(callStatement.ToString());
}
else if (TryAdaptArgumentList(context, adaptedInvocationArguments, out var adaptedArguments))
{
adaptedCallStatement = JassSyntaxFactory.CallStatement(
adaptedInvocationName,
adaptedArguments);
}
else
{
adaptedCallStatement = JassSyntaxFactory.CallStatement(
adaptedInvocationName,
adaptedInvocationArguments);
}
return(true);
}
private bool TryAdaptBlzCreateInvocation <TInvocation>(
JassMapScriptAdapterContext context,
TInvocation invocation,
[NotNullWhen(true)] out string?adaptedInvocationName,
[NotNullWhen(true)] out JassArgumentListSyntax?adaptedInvocationArguments,
string replacementFunctionName,
int expectedArgumentCount,
int typeIdArgumentIndex,
int skinIdArgumentIndex)
where TInvocation : IInvocationSyntax
{
if (invocation.Arguments.Arguments.Length == expectedArgumentCount &&
invocation.Arguments.Arguments[typeIdArgumentIndex].TryGetIntegerExpressionValue(out var typeId) &&
invocation.Arguments.Arguments[skinIdArgumentIndex].TryGetIntegerExpressionValue(out var skinId))
{
if (typeId == skinId)
{
var arguments = new IExpressionSyntax[expectedArgumentCount - 1];
for (var i = 0; i < expectedArgumentCount; i++)
{
if (i == skinIdArgumentIndex)
{
continue;
}
arguments[i > skinIdArgumentIndex ? i - 1 : i] = invocation.Arguments.Arguments[i];
}
adaptedInvocationName = replacementFunctionName;
adaptedInvocationArguments = JassSyntaxFactory.ArgumentList(arguments);
return(true);
}
else
{
context.Diagnostics.Add($"Unable to adapt '{invocation.IdentifierName}' to '{replacementFunctionName}', because the skin '{skinId.ToRawcode()}' is not the same as the type '{typeId.ToRawcode()}'.");
}
}
