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)); }