private void CreateClassSyntax()
{
var baseType = SyntaxFactory.IdentifierName("IMyLevelScript");
if (!(m_objectBuilder is MyObjectBuilder_VisualLevelScript))
{
baseType = string.IsNullOrEmpty(m_objectBuilder.Interface) ? null : SyntaxFactory.IdentifierName(m_baseType.Name);
}
m_scriptClassDeclaration = MySyntaxFactory.PublicClass(m_scriptName);
if (baseType != null)
{
m_scriptClassDeclaration = m_scriptClassDeclaration
.WithBaseList(
SyntaxFactory.BaseList(
SyntaxFactory.SingletonSeparatedList <BaseTypeSyntax>(
SyntaxFactory.SimpleBaseType(
baseType
)
)
)
);
}
}
private void AddMissingInterfaceMethods()
{
if (!m_baseType.IsInterface)
{
return;
}
foreach (var methodInfo in m_baseType.GetMethods())
{
var exists = false;
foreach (var declaration in m_methodDeclarations)
{
if (declaration.Identifier.ToFullString() == methodInfo.Name)
{
exists = true;
break;
}
}
if (exists)
{
continue;
}
// isSpecialName is true for properties
var attr = methodInfo.GetCustomAttribute <VisualScriptingMember>();
if (attr == null || attr.Reserved || methodInfo.IsSpecialName)
{
continue;
}
// Create missing syntax
m_methodDeclarations.Add(MySyntaxFactory.MethodDeclaration(methodInfo));
}
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
// Base will traverse to input nodes
base.CollectInputExpressions(expressions);
string firstVariableName = null, secondVariableName = null;
// Save names of variables
firstVariableName = m_inputANode.VariableSyntaxName(ObjectBuilder.InputAID.VariableName);
secondVariableName = m_inputBNode != null?m_inputBNode.VariableSyntaxName(ObjectBuilder.InputBID.VariableName) : "null";
if (m_inputBNode == null && ObjectBuilder.Operation != "==" && ObjectBuilder.Operation != "!=")
{
throw new Exception("Null check with Operation " + ObjectBuilder.Operation + " is prohibited.");
}
// Create expression for arithmetic operation
Debug.Assert(!string.IsNullOrEmpty(firstVariableName) && !string.IsNullOrEmpty(secondVariableName));
expressions.Add(
MySyntaxFactory.ArithmeticStatement(
VariableSyntaxName(),
firstVariableName,
secondVariableName,
ObjectBuilder.Operation)
);
}
// Takes array of key indexs and recursively creates syntax for condition clause.
private ExpressionSyntax CreateAndClauses(int index, List <int> keyIndexes)
{
var literal = MySyntaxFactory.Literal(ObjectBuilder.OuputTypes[keyIndexes[index]], ObjectBuilder.Keys[keyIndexes[index]]);
if (index == 0)
{
return(SyntaxFactory.BinaryExpression(
SyntaxKind.EqualsExpression,
SyntaxFactory.IdentifierName(ObjectBuilder.OutputNames[keyIndexes[index]]),
literal
));
}
var currentExpression = SyntaxFactory.BinaryExpression(
SyntaxKind.EqualsExpression,
SyntaxFactory.IdentifierName(ObjectBuilder.OutputNames[keyIndexes[index]]),
literal
);
return(SyntaxFactory.BinaryExpression(
SyntaxKind.LogicalAndExpression,
CreateAndClauses(--index, keyIndexes),
currentExpression
));
}
private void InitUsing()
{
if (m_methodInfo.DeclaringType == null)
{
return;
}
Using = MySyntaxFactory.UsingStatementSyntax(m_methodInfo.DeclaringType.Namespace);
}
public MethodDeclarationSyntax GetMethodDeclaration()
{
return(MySyntaxFactory.PublicMethodDeclaration(
m_method.Name,
SyntaxKind.VoidKeyword,
ObjectBuilder.OutputNames,
ObjectBuilder.OuputTypes
));
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
var entryType = MyVisualScriptingProxy.GetType(ObjectBuilder.Type);
var listType = typeof(List <>).MakeGenericType(entryType);
var separatedList = new List <SyntaxNodeOrToken>();
// Create source of arguments for array creation syntax
for (var index = 0; index < ObjectBuilder.DefaultEntries.Count; index++)
{
var entry = ObjectBuilder.DefaultEntries[index];
var literal = MySyntaxFactory.Literal(ObjectBuilder.Type, entry);
separatedList.Add(literal);
if (index < ObjectBuilder.DefaultEntries.Count - 1)
{
separatedList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
}
// Syntax of "new Type[]{arg0, arg1, ...}"
ArrayCreationExpressionSyntax arrayCreationSyntax = null;
if (separatedList.Count > 0)
{
arrayCreationSyntax = SyntaxFactory.ArrayCreationExpression(
SyntaxFactory.ArrayType(
SyntaxFactory.IdentifierName(ObjectBuilder.Type),
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression()
)
)
)
),
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
separatedList
)
)
);
}
// Syntax of new List<Type>(arrayCreationSyntax);
var listCreationSyntax = MySyntaxFactory.GenericObjectCreation(listType, arrayCreationSyntax == null ? null : new[] { arrayCreationSyntax });
var localVariableSyntax = MySyntaxFactory.LocalVariable(listType, VariableSyntaxName(), listCreationSyntax);
expressions.Add(localVariableSyntax);
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
expressions.Add(
MySyntaxFactory.CastExpression(
m_inputNode.VariableSyntaxName(ObjectBuilder.InputID.VariableName),
ObjectBuilder.Type,
VariableSyntaxName())
);
}
private void CreateVariablesAndConstructorSyntax()
{
m_constructor = MySyntaxFactory.Constructor(m_scriptClassDeclaration);
var variables = m_navigator.OfType <MyVisualSyntaxVariableNode>();
foreach (var variableNode in variables)
{
m_fieldDeclarations.Add(variableNode.CreateFieldDeclaration());
m_constructor = m_constructor.AddBodyStatements(variableNode.CreateInitializationSyntax());
}
}
private StatementSyntax CreateScriptInvocationSyntax(List <StatementSyntax> dependentStatements)
{
// Collect names of value supplier variables
List <string> variableIdentifiers = ObjectBuilder.Inputs.Select((t, index) => Inputs[index].VariableSyntaxName(t.Input.VariableName)).ToList();
// add instance method invocation
var invocationExpression = MySyntaxFactory.MethodInvocation("RunScript", variableIdentifiers, m_instanceName);
if (dependentStatements == null)
{
return(SyntaxFactory.ExpressionStatement(invocationExpression));
}
var ifStatement = MySyntaxFactory.IfExpressionSyntax(invocationExpression, dependentStatements);
return(ifStatement);
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
List <string> uniqueVariableIdentifiers = new List <string>();
for (var i = 0; i < ObjectBuilder.InputNames.Count; i++)
{
uniqueVariableIdentifiers.Add(Inputs[i].VariableSyntaxName(ObjectBuilder.InputIDs[i].VariableName));
}
expressions.Add(
SyntaxFactory.ExpressionStatement(
MySyntaxFactory.MethodInvocation(ObjectBuilder.TriggerName, uniqueVariableIdentifiers)
)
);
base.CollectInputExpressions(expressions);
}
private StatementSyntax GetCorrectAssignmentsExpression()
{
// Determine Type and create correct assingment
var boundVariableNode = Navigator.GetVariable(ObjectBuilder.VariableName);
Debug.Assert(boundVariableNode != null, "Missing variable: " + ObjectBuilder.VariableName);
var type = MyVisualScriptingProxy.GetType(boundVariableNode.ObjectBuilder.VariableType);
if (type == typeof(string))
{
if (ObjectBuilder.ValueInputID.NodeID == -1)
{
return(MySyntaxFactory.VariableAssignmentExpression(ObjectBuilder.VariableName, ObjectBuilder.VariableValue, SyntaxKind.StringLiteralExpression));
}
}
else if (type == typeof(Vector3D))
{
if (ObjectBuilder.ValueInputID.NodeID == -1)
{
return(MySyntaxFactory.SimpleAssignment(ObjectBuilder.VariableName, MySyntaxFactory.NewVector3D(ObjectBuilder.VariableValue)));
}
}
else if (type == typeof(bool))
{
if (ObjectBuilder.ValueInputID.NodeID == -1)
{
var normalizedValue = MySyntaxFactory.NormalizeBool(ObjectBuilder.VariableValue);
var syntaxKind = normalizedValue == "true" ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression;
return(MySyntaxFactory.VariableAssignmentExpression(
ObjectBuilder.VariableName, ObjectBuilder.VariableValue, syntaxKind));
}
}
else
{
if (ObjectBuilder.ValueInputID.NodeID == -1)
{
return(MySyntaxFactory.VariableAssignmentExpression(ObjectBuilder.VariableName, ObjectBuilder.VariableValue, SyntaxKind.NumericLiteralExpression));
}
}
return(MySyntaxFactory.SimpleAssignment(ObjectBuilder.VariableName, SyntaxFactory.IdentifierName(m_inputVariableName)));
}
internal override void CollectSequenceExpressions(List <StatementSyntax> expressions)
{
CollectInputExpressions(expressions);
var valueVariableName = m_valueInput.VariableSyntaxName(ObjectBuilder.ValueInput.VariableName);
var switchSections = new List <SwitchSectionSyntax>();
var syntaxList = new List <StatementSyntax>();
for (int index = 0; index < m_sequenceOutputs.Count; index++)
{
var sequenceOutputNode = m_sequenceOutputs[index];
if (sequenceOutputNode == null)
{
continue;
}
syntaxList.Clear();
// Collect
sequenceOutputNode.CollectSequenceExpressions(syntaxList);
// Add break to the end of the section
syntaxList.Add(SyntaxFactory.BreakStatement());
// New section syntax
var section = SyntaxFactory.SwitchSection().WithLabels(
SyntaxFactory.SingletonList <SwitchLabelSyntax>(
SyntaxFactory.CaseSwitchLabel(
MySyntaxFactory.Literal(ObjectBuilder.NodeType, ObjectBuilder.Options[index].Option)
)
)).WithStatements(SyntaxFactory.List(syntaxList));
switchSections.Add(section);
}
var switchSyntax = SyntaxFactory.SwitchStatement(
SyntaxFactory.IdentifierName(valueVariableName)
)
.WithSections(SyntaxFactory.List(switchSections));
expressions.Add(switchSyntax);
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
var value = ObjectBuilder.Value ?? string.Empty;
var type = MyVisualScriptingProxy.GetType(ObjectBuilder.Type);
base.CollectInputExpressions(expressions);
// First handle special cases as Color and Enums
if (type == typeof(Color) || type.IsEnum)
{
expressions.Add(
MySyntaxFactory.LocalVariable(
ObjectBuilder.Type,
VariableSyntaxName(),
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(ObjectBuilder.Type),
SyntaxFactory.IdentifierName(ObjectBuilder.Value)
)
)
);
}
else if (type == typeof(Vector3D))
{
expressions.Add(
MySyntaxFactory.LocalVariable(ObjectBuilder.Type, VariableSyntaxName(),
MySyntaxFactory.NewVector3D(ObjectBuilder.Value)
)
);
}
else
{
// Rest is generic
expressions.Add(
MySyntaxFactory.LocalVariable(
ObjectBuilder.Type,
VariableSyntaxName(),
MySyntaxFactory.Literal(ObjectBuilder.Type, value))
);
}
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
// Base will traverse to input nodes
base.CollectInputExpressions(expressions);
string firstVariableName = null, secondVariableName = null;
// Save names of variables
firstVariableName = m_inputANode.VariableSyntaxName(ObjectBuilder.InputAID.VariableName);
secondVariableName = m_inputBNode.VariableSyntaxName(ObjectBuilder.InputBID.VariableName);
// Create expression for arithmetic operation
Debug.Assert(!string.IsNullOrEmpty(firstVariableName) && !string.IsNullOrEmpty(secondVariableName));
expressions.Add(
MySyntaxFactory.ArithmeticStatement(
VariableSyntaxName(),
firstVariableName,
secondVariableName,
ObjectBuilder.Operation)
);
}
static void Analyze(SyntaxNodeAnalysisContext context)
{
var typeDecl = (TypeDeclarationSyntax)context.Node;
var semanticModel = context.SemanticModel;
var typeSymbol = semanticModel.GetDeclaredSymbol(typeDecl);
if (typeSymbol == null || typeSymbol.IsAbstract || typeSymbol.IsStatic)
{
return;
}
var varMembers = new VariableMemberCollector(semanticModel).Collect(typeDecl);
if (varMembers.All(v => v.HasInitializer))
{
return;
}
var languageVersion =
(typeDecl.SyntaxTree.Options as CSharpParseOptions)?.LanguageVersion
?? LanguageVersion.CSharp6;
var factory = new MySyntaxFactory(languageVersion);
factory.FixCompleteConstructor(semanticModel, typeDecl, varMembers, out var constructorDecl, out var fix);
if (constructorDecl != null &&
fix != null &&
constructorDecl.Identifier != null &&
typeDecl.Identifier != null
)
{
context.ReportDiagnostic(
Diagnostic.Create(
DiagnosticProvider.CompleteConstructorFix,
constructorDecl.Identifier.GetLocation(),
typeDecl.Identifier.Text
));
}
}
internal override void CollectSequenceExpressions(List <StatementSyntax> expressions)
{
// Create conditional statement for easier event evaluation.
// Considering the first parameter is the key.
if (ObjectBuilder.SequenceOutputID == -1)
{
return;
}
var nextSequenceNode = Navigator.GetNodeByID(ObjectBuilder.SequenceOutputID);
var ifBodyExpressions = new List <StatementSyntax>();
// Collect the syntax from the true branch
nextSequenceNode.CollectSequenceExpressions(ifBodyExpressions);
var keyIndexes = new List <int>();
var parameters = m_fieldInfo.FieldType.GetMethod("Invoke").GetParameters();
var attribute = m_fieldInfo.FieldType.GetCustomAttribute <VisualScriptingEvent>();
// Find the keys of this key event
for (var index = 0; index < parameters.Length; index++)
{
if (index >= attribute.IsKey.Length)
{
break;
}
if (attribute.IsKey[index])
{
keyIndexes.Add(index);
}
}
// generate the condition statement
var condition = CreateAndClauses(keyIndexes.Count - 1, keyIndexes);
var ifStatment = MySyntaxFactory.IfExpressionSyntax(condition, ifBodyExpressions);
expressions.Add(ifStatment);
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
// just for the sake of adding the assignments all at once after the
// value supplier operations.
List <StatementSyntax> assignments = new List <StatementSyntax>(ObjectBuilder.Inputs.Count);
for (int index = 0; index < ObjectBuilder.Inputs.Count; index++)
{
var valueInputNode = m_inputNodes[index];
//valueSupplierNode.CollectInputExpressions(expressions, this);
var inputVarName = valueInputNode.VariableSyntaxName(ObjectBuilder.Inputs[index].Input.VariableName);
var assignment = MySyntaxFactory.SimpleAssignment(ObjectBuilder.Inputs[index].Name, SyntaxFactory.IdentifierName(inputVarName));
assignments.Add(assignment);
}
// Add "return true;"
expressions.Add(SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)));
expressions.AddRange(assignments);
}
public ExpressionStatementSyntax CreateInitializationSyntax()
{
if (m_variableType.IsGenericType)
{
var objectCreationSyntax = MySyntaxFactory.GenericObjectCreation(m_variableType);
var variableAssignmentExpression = MySyntaxFactory.VariableAssignment(ObjectBuilder.VariableName, objectCreationSyntax);
return(SyntaxFactory.ExpressionStatement(variableAssignmentExpression));
}
if (m_variableType == typeof(Vector3D))
{
return(MySyntaxFactory.VectorAssignmentExpression(
ObjectBuilder.VariableName, ObjectBuilder.VariableType,
ObjectBuilder.Vector.X, ObjectBuilder.Vector.Y, ObjectBuilder.Vector.Z
));
}
if (m_variableType == typeof(string))
{
return(MySyntaxFactory.VariableAssignmentExpression(
ObjectBuilder.VariableName, ObjectBuilder.VariableValue, SyntaxKind.StringLiteralExpression
));
}
if (m_variableType == typeof(bool))
{
var normalizedValue = MySyntaxFactory.NormalizeBool(ObjectBuilder.VariableValue);
var syntaxKind = normalizedValue == "true"
? SyntaxKind.TrueLiteralExpression
: SyntaxKind.FalseLiteralExpression;
return(MySyntaxFactory.VariableAssignmentExpression(
ObjectBuilder.VariableName, ObjectBuilder.VariableValue, syntaxKind));
}
return(MySyntaxFactory.VariableAssignmentExpression(
ObjectBuilder.VariableName, ObjectBuilder.VariableValue, SyntaxKind.NumericLiteralExpression
));
}
internal override void CollectSequenceExpressions(List <StatementSyntax> expressions)
{
// Collect mine input expressions and pushed expressions
CollectInputExpressions(expressions);
var trueStatments = new List <StatementSyntax>();
var falseStatments = new List <StatementSyntax>();
// Sequence outputs can be connected only to one input
if (m_nextTrueSequenceNode != null)
{
m_nextTrueSequenceNode.CollectSequenceExpressions(trueStatments);
}
if (m_nextFalseSequenceNode != null)
{
m_nextFalseSequenceNode.CollectSequenceExpressions(falseStatments);
}
var inputNodeVariableName = m_comparerNode.VariableSyntaxName(ObjectBuilder.InputID.VariableName);
// write my expression before the collected inputs
expressions.Add(MySyntaxFactory.IfExpressionSyntax(inputNodeVariableName, trueStatments, falseStatments));
}
internal override void CollectSequenceExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
// We can ignore the nodes with empty bodies
if (m_bodySequence != null)
{
var bodySyntax = new List <StatementSyntax>();
// Collect body expressions
m_bodySequence.CollectSequenceExpressions(bodySyntax);
// Create syntax for first index of for loop
ExpressionSyntax firstIndexExpression;
if (m_firstInput != null)
{
firstIndexExpression = SyntaxFactory.IdentifierName(
m_firstInput.VariableSyntaxName(ObjectBuilder.FirstIndexValueInput.VariableName)
);
}
else
{
firstIndexExpression = MySyntaxFactory.Literal(
typeof(int).Signature(),
ObjectBuilder.FirstIndexValue
);
}
// Create syntax for last index condition
ExpressionSyntax lastIndexExpression;
if (m_lastInput != null)
{
lastIndexExpression = SyntaxFactory.IdentifierName(
m_lastInput.VariableSyntaxName(ObjectBuilder.LastIndexValueInput.VariableName)
);
}
else
{
lastIndexExpression = MySyntaxFactory.Literal(typeof(int).Signature(), ObjectBuilder.LastIndexValue);
}
// Create syntax for increment
ExpressionSyntax incrementExpression;
if (m_incrementInput != null)
{
incrementExpression = SyntaxFactory.IdentifierName(
m_incrementInput.VariableSyntaxName(ObjectBuilder.IncrementValueInput.VariableName)
);
}
else
{
incrementExpression = MySyntaxFactory.Literal(typeof(int).Signature(), ObjectBuilder.IncrementValue);
}
// Put the for statement syntax together
var forStatement = SyntaxFactory.ForStatement(
SyntaxFactory.Block(bodySyntax)
).WithDeclaration(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(SyntaxKind.IntKeyword)))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(VariableSyntaxName()))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
firstIndexExpression
)
)
)
)
).WithCondition(
SyntaxFactory.BinaryExpression(
SyntaxKind.LessThanOrEqualExpression,
SyntaxFactory.IdentifierName(VariableSyntaxName()),
lastIndexExpression
)
).WithIncrementors(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.AssignmentExpression(
SyntaxKind.AddAssignmentExpression,
SyntaxFactory.IdentifierName(VariableSyntaxName()),
incrementExpression
)
)
);
expressions.Add(forStatement);
}
// Ignore if not present
if (m_finishSequence != null)
{
m_finishSequence.CollectSequenceExpressions(expressions);
}
}
private void FinalizeSyntax()
{
// Dispose method handling
var disposeFound = false;
// For empty dispose we dont want to merge it really
for (var i = 0; i < m_methodDeclarations.Count; i++)
{
if (m_methodDeclarations[i].Identifier.ToString() == m_disposeMethod.Identifier.ToString())
{
// Dont add empty body to the already created one
if (m_disposeMethod.Body.Statements.Count > 0)
{
m_methodDeclarations[i] = m_methodDeclarations[i].AddBodyStatements(m_disposeMethod.Body);
}
disposeFound = true;
break;
}
}
if (!disposeFound)
{
m_methodDeclarations.Add(m_disposeMethod);
}
AddMissingInterfaceMethods();
// if the interface type is objective logic script we need to hack in the rest of the interface methods
if (m_baseType == typeof(IMyStateMachineScript))
{
AddMissionLogicScriptMethods();
}
m_scriptClassDeclaration = m_scriptClassDeclaration.AddMembers(m_fieldDeclarations.ToArray());
m_scriptClassDeclaration = m_scriptClassDeclaration.AddMembers(m_constructor);
m_scriptClassDeclaration = m_scriptClassDeclaration.AddMembers(m_methodDeclarations.ToArray());
m_namespaceDeclaration = m_namespaceDeclaration.AddMembers(m_scriptClassDeclaration);
var usings = new List <UsingDirectiveSyntax>();
var usingsUniqueSet = new HashSet <string>();
var defaultUsing = MySyntaxFactory.UsingStatementSyntax("VRage.Game.VisualScripting");
usings.Add(defaultUsing);
usingsUniqueSet.Add(defaultUsing.ToFullString());
foreach (var node in m_navigator.OfType <MyVisualSyntaxFunctionNode>())
{
if (usingsUniqueSet.Add(node.Using.ToFullString()))
{
usings.Add(node.Using);
}
}
foreach (var node in m_navigator.OfType <MyVisualSyntaxVariableNode>())
{
if (usingsUniqueSet.Add(node.Using.ToFullString()))
{
usings.Add(node.Using);
}
}
m_compilationUnit = SyntaxFactory.CompilationUnit().WithUsings(SyntaxFactory.List(
usings
)).AddMembers(m_namespaceDeclaration).NormalizeWhitespace();
}
internal override void CollectSequenceExpressions(List <StatementSyntax> expressions)
{
// Collect input only from these nodes that are inputs for this node.
m_toCollectNodeCache.Clear();
foreach (var subTreeNode in SubTreeNodes)
{
var directConnection = false;
foreach (var outputNode in subTreeNode.Outputs)
{
// Must be an input
if (outputNode == this && !outputNode.Collected)
{
directConnection = true;
break;
}
}
if (directConnection)
{
subTreeNode.CollectInputExpressions(expressions);
}
else
{
// Cache these that are getting the input from this one.
m_toCollectNodeCache.Add(subTreeNode);
}
}
// We can ignore the nodes with empty bodies
if (m_bodySequence != null)
{
var bodySyntax = new List <StatementSyntax>();
// Collect the assigned bodies from
foreach (var node in m_toCollectNodeCache)
{
node.CollectInputExpressions(bodySyntax);
}
// Collect body expressions
m_bodySequence.CollectSequenceExpressions(bodySyntax);
// Create syntax for first index of for loop
ExpressionSyntax firstIndexExpression;
if (m_firstInput != null)
{
firstIndexExpression = SyntaxFactory.IdentifierName(
m_firstInput.VariableSyntaxName(ObjectBuilder.FirstIndexValueInput.VariableName)
);
}
else
{
firstIndexExpression = MySyntaxFactory.Literal(
typeof(int).Signature(),
ObjectBuilder.FirstIndexValue
);
}
// Create syntax for last index condition
ExpressionSyntax lastIndexExpression;
if (m_lastInput != null)
{
lastIndexExpression = SyntaxFactory.IdentifierName(
m_lastInput.VariableSyntaxName(ObjectBuilder.LastIndexValueInput.VariableName)
);
}
else
{
lastIndexExpression = MySyntaxFactory.Literal(typeof(int).Signature(), ObjectBuilder.LastIndexValue);
}
// Create syntax for increment
ExpressionSyntax incrementExpression;
if (m_incrementInput != null)
{
incrementExpression = SyntaxFactory.IdentifierName(
m_incrementInput.VariableSyntaxName(ObjectBuilder.IncrementValueInput.VariableName)
);
}
else
{
incrementExpression = MySyntaxFactory.Literal(typeof(int).Signature(), ObjectBuilder.IncrementValue);
}
// Put the for statement syntax together
var forStatement = SyntaxFactory.ForStatement(
SyntaxFactory.Block(bodySyntax)
).WithDeclaration(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(SyntaxKind.IntKeyword)))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(VariableSyntaxName()))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
firstIndexExpression
)
)
)
)
).WithCondition(
SyntaxFactory.BinaryExpression(
SyntaxKind.LessThanOrEqualExpression,
SyntaxFactory.IdentifierName(VariableSyntaxName()),
lastIndexExpression
)
).WithIncrementors(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.AssignmentExpression(
SyntaxKind.AddAssignmentExpression,
SyntaxFactory.IdentifierName(VariableSyntaxName()),
incrementExpression
)
)
);
expressions.Add(forStatement);
}
// Ignore if not present
if (m_finishSequence != null)
{
m_finishSequence.CollectSequenceExpressions(expressions);
}
}
private void CreateMethods()
{
// Generate Interface methods
if (!string.IsNullOrEmpty(m_objectBuilder.Interface))
{
var methodNodes = m_navigator.OfType <MyVisualSyntaxInterfaceMethodNode>();
foreach (var methodNode in methodNodes)
{
var methodSyntax = methodNode.GetMethodDeclaration();
ProcessNodes(new[] { methodNode }, ref methodSyntax);
m_methodDeclarations.Add(methodSyntax);
}
}
var events = m_navigator.OfType <MyVisualSyntaxEventNode>();
events.AddRange(m_navigator.OfType <MyVisualSyntaxKeyEventNode>());
// Generate Event methods
// Take all events of same name and make a method out of theire bodies.
while (events.Count > 0)
{
var firstEvent = events[0];
var eventsWithSameName = events.Where(@event => @event.ObjectBuilder.Name == firstEvent.ObjectBuilder.Name);
var methodDeclaration = MySyntaxFactory.PublicMethodDeclaration(
firstEvent.EventName,
SyntaxKind.VoidKeyword,
firstEvent.ObjectBuilder.OutputNames,
firstEvent.ObjectBuilder.OuputTypes);
ProcessNodes(eventsWithSameName, ref methodDeclaration);
// Bind with VisualScriptingProxy in constructor.
m_constructor = m_constructor.AddBodyStatements(
MySyntaxFactory.DelegateAssignment(
firstEvent.ObjectBuilder.Name,
methodDeclaration.Identifier.ToString())
);
// unBind from visualScriptingProxy in dispose method
m_disposeMethod = m_disposeMethod.AddBodyStatements(
MySyntaxFactory.DelegateRemoval(
firstEvent.ObjectBuilder.Name,
methodDeclaration.Identifier.ToString())
);
m_methodDeclarations.Add(methodDeclaration);
events.RemoveAll(@event => eventsWithSameName.Contains(@event));
}
// There can be only one method from single input node.
// Input nodes are of type Event.
var inputs = m_navigator.OfType <MyVisualSyntaxInputNode>();
var outputs = m_navigator.OfType <MyVisualSyntaxOutputNode>();
if (inputs.Count > 0)
{
Debug.Assert(inputs.Count == 1);
var input = inputs[0];
MethodDeclarationSyntax methodDeclaration = null;
if (outputs.Count > 0)
{
List <string> outputParamNames = new List <string>(outputs[0].ObjectBuilder.Inputs.Count);
List <string> outputParamTypes = new List <string>(outputs[0].ObjectBuilder.Inputs.Count);
foreach (var outputData in outputs[0].ObjectBuilder.Inputs)
{
outputParamNames.Add(outputData.Name);
outputParamTypes.Add(outputData.Type);
}
methodDeclaration = MySyntaxFactory.PublicMethodDeclaration("RunScript", SyntaxKind.BoolKeyword, input.ObjectBuilder.OutputNames, input.ObjectBuilder.OuputTypes, outputParamNames, outputParamTypes);
}
else
{
methodDeclaration = MySyntaxFactory.PublicMethodDeclaration("RunScript", SyntaxKind.BoolKeyword, input.ObjectBuilder.OutputNames, input.ObjectBuilder.OuputTypes);
}
ProcessNodes(new[] { input }, ref methodDeclaration, new[] { SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)) });
m_methodDeclarations.Add(methodDeclaration);
}
}
public StatementSyntax DisposeCallDeclaration()
{
return(SyntaxFactory.ExpressionStatement(MySyntaxFactory.MethodInvocation("Dispose", null, m_instanceName)));
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
// Add local output variable declarations
expressions.AddRange(ObjectBuilder.Outputs.Select(outputData => MySyntaxFactory.LocalVariable(outputData.Type, outputData.Name)));
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
// MyLocalization.Static["context", "messageId"];
var localizationAccessExpression = SyntaxFactory.ElementAccessExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("VRage.Game.Localization.MyLocalization"),
SyntaxFactory.IdentifierName("Static")
)
).WithArgumentList(
SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
MySyntaxFactory.Literal(typeof(string).Signature(), ObjectBuilder.Context)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
MySyntaxFactory.Literal(typeof(string).Signature(), ObjectBuilder.MessageId))
})
)
);
// ToString() invocation expression
var toStringExpression = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
localizationAccessExpression,
SyntaxFactory.IdentifierName("ToString")
)
);
// String tmpVariableName = the above
string tmpVariableName = "localizedText_" + ObjectBuilder.ID;
if (m_inputParameterNodes.Count == 0)
{
tmpVariableName = VariableSyntaxName();
}
var localizedTextVariableSyntax = MySyntaxFactory.LocalVariable(typeof(string).Signature(),
tmpVariableName, toStringExpression);
if (m_inputParameterNodes.Count > 0)
{
// Prepare variable names for creation of string.Format call
var parameterVariableNames = new List <string>();
parameterVariableNames.Add(tmpVariableName);
for (int index = 0; index < m_inputParameterNodes.Count; index++)
{
var node = m_inputParameterNodes[index];
parameterVariableNames.Add(node.VariableSyntaxName(ObjectBuilder.ParameterInputs[index].VariableName));
}
// string.Format(....) call
var stringFormatSyntax = MySyntaxFactory.MethodInvocation("Format", parameterVariableNames, "string");
// node variable syntax creation
var nodeVariableSyntax = MySyntaxFactory.LocalVariable(typeof(string).Signature(), VariableSyntaxName(), stringFormatSyntax);
expressions.Add(localizedTextVariableSyntax);
expressions.Add(nodeVariableSyntax);
}
else
{
expressions.Add(localizedTextVariableSyntax);
}
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
if (Inputs.Count == 1)
{
ExpressionSyntax initializer;
if (ObjectBuilder.Operation == MyObjectBuilder_LogicGateScriptNode.LogicOperation.NOT)
{
// Initializer for NOT
initializer = SyntaxFactory.PrefixUnaryExpression(
SyntaxKind.LogicalNotExpression,
SyntaxFactory.IdentifierName(
Inputs[0].VariableSyntaxName(m_inputsToVariableNames[Inputs[0]])
)
);
}
else
{
// Initilizer for case when someone just didn't connect anything to second input
initializer = SyntaxFactory.IdentifierName(
Inputs[0].VariableSyntaxName(m_inputsToVariableNames[Inputs[0]])
);
}
// Local variable without binary expression
var localVariable = MySyntaxFactory.LocalVariable(
typeof(bool).Signature(),
VariableSyntaxName(),
initializer
);
expressions.Add(localVariable);
}
else if (Inputs.Count > 1)
{
// Initial expression
ExpressionSyntax initiliazer = SyntaxFactory.BinaryExpression(
OperationKind,
SyntaxFactory.IdentifierName(Inputs[0].VariableSyntaxName(m_inputsToVariableNames[Inputs[0]])),
SyntaxFactory.IdentifierName(Inputs[1].VariableSyntaxName(m_inputsToVariableNames[Inputs[1]]))
);
// Add rest of the binary expression
for (var index = 2; index < Inputs.Count; index++)
{
var inputNode = Inputs[index];
initiliazer = SyntaxFactory.BinaryExpression(
OperationKind,
initiliazer,
SyntaxFactory.IdentifierName(
inputNode.VariableSyntaxName(
m_inputsToVariableNames[inputNode]
)
)
);
}
if (ObjectBuilder.Operation == MyObjectBuilder_LogicGateScriptNode.LogicOperation.NAND ||
ObjectBuilder.Operation == MyObjectBuilder_LogicGateScriptNode.LogicOperation.NOR)
{
// For these also add parenthesis and negation
initiliazer = SyntaxFactory.PrefixUnaryExpression(
SyntaxKind.LogicalNotExpression,
SyntaxFactory.ParenthesizedExpression(
initiliazer
)
);
}
// Local variable syntax
var localVariable = MySyntaxFactory.LocalVariable(typeof(bool).Signature(), VariableSyntaxName(), initiliazer);
expressions.Add(localVariable);
}
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
// Insert expressions from connected nodes
base.CollectInputExpressions(expressions);
// Create container variables for output parameters.
// Assign correct identifiers to method call.
var args = new List <SyntaxNodeOrToken>();
var parameters = m_methodInfo.GetParameters();
var index = 0;
// Skip the first parameter for extension methods.
if (m_methodInfo.IsDefined(typeof(ExtensionAttribute), false))
{
index++;
}
for (; index < parameters.Length; index++)
{
var parameter = parameters[index];
// Create container variables for output parameters.
if (parameter.IsOut)
{
// Output parameters
var localOutputVariableName = VariableSyntaxName(parameter.Name);
// add variable creation expression
expressions.Add(MySyntaxFactory.LocalVariable(parameter.ParameterType.GetElementType().Signature(), localOutputVariableName));
// add variable name to parameters
args.Add(SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(localOutputVariableName)
).WithNameColon(SyntaxFactory.NameColon(parameter.Name))
.WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)
)
);
}
// Get the names of the variables supplying the values to the method call
else
{
// Find the value input node
MyTuple <MyVisualSyntaxNode, MyVariableIdentifier> inputData;
if (m_parametersToInputs.TryGetValue(parameter, out inputData))
{
// FOUND!
// add variable name to arguments
var variableName = inputData.Item1.VariableSyntaxName(inputData.Item2.VariableName);
Debug.Assert(variableName != null);
args.Add(SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(
variableName
)
).WithNameColon(SyntaxFactory.NameColon(parameter.Name))
);
}
else
{
// Not FOUND! will be probably an constant argument
var paramValue =
ObjectBuilder.InputParameterValues.Find(value => value.ParameterName == parameter.Name);
if (paramValue == null)
{
// Dont panic, there could be still the default value.
if (!parameter.HasDefaultValue)
{
// Add null / some default value
args.Add(
MySyntaxFactory.ConstantDefaultArgument(parameter.ParameterType)
.WithNameColon(SyntaxFactory.NameColon(parameter.Name))
);
}
else
{
// default value will take care of this
continue; // no comma for you args
}
}
else
{
// Add constant value to arguments
args.Add(MySyntaxFactory.ConstantArgument(
parameter.ParameterType.Signature(), paramValue.Value
).WithNameColon(SyntaxFactory.NameColon(parameter.Name))
);
}
}
}
// add comma
args.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
// remove last comma
if (args.Count > 0)
{
args.RemoveAt(args.Count - 1);
}
// Create the invocation syntax
InvocationExpressionSyntax methodInvocation = null;
if (m_methodInfo.IsStatic && !m_methodInfo.IsDefined(typeof(ExtensionAttribute)))
{
// Static call
methodInvocation = MySyntaxFactory.MethodInvocationExpressionSyntax(
SyntaxFactory.IdentifierName(m_methodInfo.DeclaringType.FullName + "." + m_methodInfo.Name),
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(args))
);
}
else
{
var declaringType = m_methodInfo.DeclaringType;
// Non static local method invocation
if (declaringType == m_scriptBaseType)
{
methodInvocation = MySyntaxFactory.MethodInvocationExpressionSyntax(
SyntaxFactory.IdentifierName(m_methodInfo.Name),
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(args))
);
}
// Non static instance method invocation or extension method
else
{
if (m_instance == null)
{
throw new Exception("FunctionNode: " + ObjectBuilder.ID +
" Is missing mandatory instance input.");
}
var instanceVariableName = m_instance.VariableSyntaxName(ObjectBuilder.InstanceInputID.VariableName);
methodInvocation = MySyntaxFactory.MethodInvocationExpressionSyntax(
SyntaxFactory.IdentifierName(m_methodInfo.Name),
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(args)),
SyntaxFactory.IdentifierName(instanceVariableName)
);
}
}
// Finalize the syntax
if (m_methodInfo.ReturnType == typeof(void))
{
// just add invocation
expressions.Add(
SyntaxFactory.ExpressionStatement(methodInvocation)
);
}
else
{
// Create variable for return value
expressions.Add(
MySyntaxFactory.LocalVariable(
string.Empty,
VariableSyntaxName("Return"),
methodInvocation
)
);
}
}
public ImmutableArray <string> Collect()
{
var typeDecls =
Root
.DescendantNodesAndSelf()
.OfType <TypeDeclarationSyntax>()
.ToImmutableArray();
var items = new List <(TypeDeclarationSyntax typeDecl, ImmutableArray <string> deriveNames)>();
foreach (var typeDecl in typeDecls)
{
var typeSym = (ITypeSymbol)Model.GetDeclaredSymbol(typeDecl);
if (!TryAnalyzeTypeDeclWithDeriveAttribute(typeDecl, out var deriveNames))
{
continue;
}
items.Add((typeDecl, deriveNames));
}
if (items.Count == 0)
{
return(ImmutableArray <string> .Empty);
}
// Render:
var sf = new MySyntaxFactory(LanguageVersion.CSharp5);
var partialTypeDecls = new List <MemberDeclarationSyntax>();
foreach (var(typeDecl, deriveNames) in items)
{
Logger.WriteLine($"#![derive({string.Join(", ", deriveNames)})]");
Logger.WriteLine($"class {typeDecl.Identifier.ToString()};");
var varMembers = new VariableMemberCollector(Model).Collect(typeDecl);
var ctor = sf.CompleteConstructor(Model, typeDecl, varMembers);
var partialTypeDecl =
typeDecl
.WithLeadingTrivia(SyntaxFactory.TriviaList())
.WithTrailingTrivia(SyntaxFactory.TriviaList())
.WithAttributeLists(SyntaxFactory.List <AttributeListSyntax>())
.WithModifiers(SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword),
SyntaxFactory.Token(SyntaxKind.PartialKeyword)
))
.WithMembers(new SyntaxList <MemberDeclarationSyntax>(new[]
{
ctor,
}));
partialTypeDecls.Add(partialTypeDecl);
}
var ns =
SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName("Examples.Ast"))
.WithUsings(SyntaxFactory.List <UsingDirectiveSyntax>(new[]
{
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System"))
}))
.WithMembers(SyntaxFactory.List(partialTypeDecls));
var generatedModule =
SyntaxFactory
.CompilationUnit()
.WithMembers(SyntaxFactory.List <MemberDeclarationSyntax>(new[] { ns }))
.WithAdditionalAnnotations(
Formatter.Annotation,
Simplifier.Annotation
);
var formatted = Formatter.Format(generatedModule, Workspace);
var generatedDoc = Project.AddDocument("Sharperform.g.cs", formatted);
var simplified = Simplifier.ReduceAsync(generatedDoc).Result;
var generatedCode = simplified.GetTextAsync().Result.ToString();
Logger.WriteLine(generatedCode);
// Logger.WriteLine(formatted.ToString());
return(ImmutableArray.Create(generatedCode));
}
