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()}'."); } }