/// <summary> /// Takes a synchronous OperationContract method and returns a corresponding asynchronous method pair /// </summary> /// <param name="originalMethod"></param> /// <returns></returns> private static IEnumerable<MemberDeclarationSyntax> ComputeNewOperationContractNodes(MethodDeclarationSyntax originalMethod) { // Turn the original method into a 'Begin' method with additional Async parameters.. IEnumerable<ParameterSyntax> extraParameters = new List<ParameterSyntax> { Syntax.Parameter(Syntax.Identifier("callback")).WithType(Syntax.IdentifierName(typeof (AsyncCallback).Name)), Syntax.Parameter(Syntax.Identifier("state")).WithType(Syntax.PredefinedType(Syntax.Token(SyntaxKind.ObjectKeyword))) }; var parameters = originalMethod.ParameterList == null ? extraParameters : originalMethod.ParameterList.Parameters.Concat(extraParameters); var seperators = Enumerable.Range(0, parameters.Count() - 1).Select(i => Syntax.Token(SyntaxKind.CommaToken)); var beginMethod = originalMethod .WithReturnType(Syntax.IdentifierName(typeof(IAsyncResult).Name)) .WithIdentifier(Syntax.Identifier("Begin" + originalMethod.Identifier.ValueText)) .WithParameterList(Syntax.ParameterList(Syntax.SeparatedList(parameters, seperators))); // Alter the OperationContractAttribute to specify AsyncPattern = true var operationContractAttribute = beginMethod.GetAttribute<OperationContractAttribute>(); beginMethod = beginMethod.ReplaceNodes(new[] { operationContractAttribute }, (x, y) => ComputeNewOperationContractAttributeNode(x)); // Create the 'End' method var endMethod = Syntax.MethodDeclaration(originalMethod.ReturnType, Syntax.Identifier("End" + originalMethod.Identifier.ValueText)) .WithParameterList( Syntax.ParameterList(Syntax.SeparatedList(Syntax.Parameter(Syntax.Identifier("result")).WithType(Syntax.IdentifierName(typeof(IAsyncResult).Name))))) .WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken)); return new[] { beginMethod, endMethod }; }
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) { var methodDecl = (MethodDeclarationSyntax)base.VisitMethodDeclaration(node); var methodSymbol = _semanticModel.GetDeclaredSymbol(methodDecl); if (methodSymbol.IsAbstract) { return methodDecl; } List<GuardedParameter> guardsToEmit = _inspector.Inspect(methodDecl, methodSymbol); List<StatementSyntax> bodyStatements = guardsToEmit.SelectMany(g => g.Emitters.Select(y => y.Emitter.EmitGuard(y.Attribute, g.ParameterType, g.ParameterName))).ToList(); //Add original body back in bodyStatements.AddRange(methodDecl.Body.Statements); return Syntax.MethodDeclaration( methodDecl.AttributeLists, methodDecl.Modifiers, methodDecl.ReturnType, methodDecl.ExplicitInterfaceSpecifier, methodDecl.Identifier, methodDecl.TypeParameterList, methodDecl.ParameterList, methodDecl.ConstraintClauses, Syntax.Block(bodyStatements)); }
private static void HandleDeclarations(MethodDeclarationSyntax method) { var declarations = method.DescendentNodes().OfType<VariableDeclarationSyntax>(); foreach (var declaration in declarations) { Console.WriteLine("\t\t\td: " + declaration.Type.PlainName); } }
public List<GuardedParameter> Inspect(MethodDeclarationSyntax method, MethodSymbol methodSymbol) { List<GuardedParameter> guardedParameters = new List<GuardedParameter>(); InspectHierarchy(methodSymbol, guardedParameters); return guardedParameters; }
public int GetNestingLevelMethod(MethodDeclarationSyntax methodDeclaration) { var nestings = GetStatementSyntaxs(methodDeclaration) .Select(statementSyntax => GetNestingLevelStatement(statementSyntax, methodDeclaration)) .ToList(); return nestings.Count == 0 ? 0 : nestings.OrderByDescending(nesting => nesting).First(); }
private static void HandleConstructorInvocations(ISemanticModel sema, MethodDeclarationSyntax method) { var ctors = method.DescendentNodes().OfType<ObjectCreationExpressionSyntax>(); foreach (var ctor in ctors) { var ctorSymbols = sema.GetSemanticInfo(ctor); Console.WriteLine("\t\t\tc: " + ctorSymbols.Symbol.ContainingType.Name); } }
private static void HandleInvocations(ISemanticModel sema, MethodDeclarationSyntax method) { var invocations = method.DescendentNodes().OfType<InvocationExpressionSyntax>(); foreach (var invocation in invocations) { var invocSymbols = sema.GetSemanticInfo(invocation); Console.WriteLine("\t\t\ti: " + invocSymbols.Symbol.ContainingType.Name); } }
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) { var methodSymbol = semanticModel.GetDeclaredSymbol(node); var dllImportData = methodSymbol.GetDllImportData(); if (dllImportData == null) { return base.VisitMethodDeclaration(node); } var delegateKeyword = Syntax.Token(SyntaxKind.DelegateKeyword); var unmanagedFunctionPointerAttribute = BuildUnmanagedFunctionPointerAttribute(dllImportData); var returnKeywordAttributes = node.AttributeLists.Where(syntax => syntax.Target != null && syntax.Target.Identifier.Kind == SyntaxKind.ReturnKeyword); var delegateDeclaration = Syntax.DelegateDeclaration(node.ReturnType, node.Identifier.ValueText + "Delegate") .WithDelegateKeyword(delegateKeyword) .WithParameterList(node.ParameterList) .WithAttributeLists(unmanagedFunctionPointerAttribute) .AddAttributeLists(returnKeywordAttributes.ToArray()); var variableDeclarator = Syntax.VariableDeclarator(string.Format("library = new UnmanagedLibrary(\"{0}\")", dllImportData.ModuleName)); var declarationSyntax = Syntax.VariableDeclaration(Syntax.ParseTypeName("var"), Syntax.SeparatedList(variableDeclarator)); var functionDeclarationStatement = "var function = library.GetUnmanagedFunction<{0}Delegate>(\"{1}\");"; var nativeFunctionName = dllImportData.EntryPointName ?? node.Identifier.ValueText; var functionStatement = Syntax.ParseStatement(string.Format(functionDeclarationStatement, node.Identifier.ValueText, nativeFunctionName)); var args = node.ParameterList.Parameters.Select(syntax => Syntax.Argument(Syntax.IdentifierName(syntax.Identifier))).ToList(); var argSeparators = Enumerable.Repeat(Syntax.Token(SyntaxKind.CommaToken), args.Count - 1).ToList(); var invocationExpressionSyntax = Syntax.InvocationExpression(Syntax.ParseExpression("function"), Syntax.ArgumentList(Syntax.SeparatedList(args, argSeparators))); var lastStatement = methodSymbol.ReturnsVoid ? (StatementSyntax)Syntax.ExpressionStatement(invocationExpressionSyntax) : Syntax.ReturnStatement(invocationExpressionSyntax); var usingStatementBody = Syntax.Block(functionStatement, lastStatement); var usingStatement = Syntax.UsingStatement(declarationSyntax, null, usingStatementBody); var blockSyntax = Syntax.Block(usingStatement); var methodDeclaration = Syntax.MethodDeclaration(node.ReturnType, node.Identifier) .WithParameterList(node.ParameterList) .WithModifiers(Syntax.TokenList(node.Modifiers.Where(token => token.Kind != SyntaxKind.ExternKeyword))) .WithBody(blockSyntax); delegateDeclarations.Add(delegateDeclaration); methodDeclarations.Add(methodDeclaration); return default(SyntaxNode); }
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) { if (IsRoleMethod) { var methodName = node.Identifier.ValueText; var methodIdentifier = Syntax.Identifier(" self__" + _roleName + "__" + methodName); node = (MethodDeclarationSyntax)node.WithIdentifier(methodIdentifier); } return base.VisitMethodDeclaration(node); }
public int GetNestingLevelMethod(MethodDeclarationSyntax methodDeclaration) { var statementSyntax = GetStatementSyntaxs(methodDeclaration); var nestings = statementSyntax.Where(statement => !(statement is BlockSyntax) && IsEnlargersNesting(statement)) .Select(i => GetNestingLevelStatement(i, methodDeclaration)) .ToList(); return nestings.Count == 0 ? 0 : nestings.OrderByDescending(nesting => nesting).First(); }
private static void HandleConditions(MethodDeclarationSyntax method) { int cc = 1; var ifs = method.DescendentNodes().OfType<IfStatementSyntax>(); foreach (var cond in ifs) { var bins = cond.Condition.DescendentNodesAndSelf().OfType<BinaryExpressionSyntax>(); cc += 1 + bins.Count(); } Console.WriteLine("\t\t\tcc: " + cc); }
public int GetLineNumberMethod(MethodDeclarationSyntax methodDeclaration) { var locationMethod = methodDeclaration.GetLocation() .GetLineSpan(false) .StartLinePosition; int lineNumber; return Int32.TryParse(locationMethod.ToString() .Split(',') .First(), out lineNumber ) ? lineNumber + 1 : -1; }
private static int GetNestingLevelStatement(StatementSyntax statement, MethodDeclarationSyntax methodDeclaration) { var nestingLevelStatement = IsEnlargersNesting(statement) ? 1 : 0; var parentStatement = statement.Parent; while (parentStatement != null && parentStatement != methodDeclaration) { if (IsEnlargersNesting(parentStatement)) nestingLevelStatement++; parentStatement = parentStatement.Parent; } return nestingLevelStatement; }
public override void VisitMethodDeclaration(MethodDeclarationSyntax node) { var symbol = model.GetDeclaredSymbol(node); if (symbol.ContainingType != null) { this.declaredItems.Add(new DeclaredItemDocument { Name = symbol.Name, Location = this.model.SyntaxTree.GetLineSpan(node.Span, false).StartLinePosition.Line, Identifier = symbol.ToDisplayString(), Type = "Method" }); } base.VisitMethodDeclaration(node); }
public override void VisitMethodDeclaration(MethodDeclarationSyntax node) { bool bPublic = false; var modifiers = node.Modifiers; if (modifiers.Any(c => c.Kind == SyntaxKind.PublicKeyword)) bPublic = true; var name = node.Identifier.GetText().ToLowerCamelCase(); var @params = VisitParameterList(node.ParameterList); _writer.WriteLine(" function {0}({1}) {{", name, @params); if (bPublic) _publicCode.WriteLine(" {0}: {1},", name, name); base.VisitMethodDeclaration(node); _writer.WriteLine(" }"); _writer.WriteLine(); }
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) { if (_pointCut.Match(node)) { var adviceType = _advice.GetType(); var paramsBuilder = new StringBuilder("new List<AOP.Framework.ObjectRep>() {"); for (int i = 0; i < node.ParameterList.Parameters.Count; i++) { var p = node.ParameterList.Parameters[i]; paramsBuilder.Append(string.Format("new AOP.Framework.ObjectRep(\"{0}\", {0})", p.Identifier.ValueText)).Append(i < (node.ParameterList.Parameters.Count - 1) ? "," : "}"); } var funcCall = string.Format("(new {0}.{1}()).Implementation(\"{2}\", {3});", adviceType.Namespace, adviceType.Name, node.Identifier.ValueText, paramsBuilder.ToString()); var statements = new List<StatementSyntax>(); if (_advice is IBeforeMethodAdvice) statements.Add(Syntax.ParseStatement(funcCall)); statements.AddRange(node.Body.Statements); if (_advice is IAfterMethodAdvice) statements.Add(Syntax.ParseStatement(funcCall)); return node.WithBody(Syntax.Block(statements).NormalizeWhitespace()); } return node; }
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) { identities.Clear(); return(base.VisitMethodDeclaration(node)); }
// Determine if a method needs parameter added to signature private bool NeedsMethodParameter(MethodDeclarationSyntax node) => node.ParameterList != null && !node.ParameterList.Parameters.Any(predicate => predicate.Type.ToString().EndsWith(parmTypeName)) && methodNames.Contains(node.Identifier.ValueText);
// Add method parameter to qualifying method public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) => NeedsMethodParameter(node) ? base.VisitMethodDeclaration(node.PrependParameter(CreateParameter()).NormalizeWhitespace()) : base.VisitMethodDeclaration(node);
private static void HandleMethodLength(MethodDeclarationSyntax method) { var methodVisit = new DemoAstVisitor(); methodVisit.Visit(method); Console.WriteLine("\t\t\tml: " + (methodVisit.Lines - 1)); }
private static void HandleStatements(MethodDeclarationSyntax method) { var statements = method.DescendentNodes().OfType<StatementSyntax>(); Console.WriteLine("\t\t\tns: " + statements.Count(s => !(s is BlockSyntax))); }
public int GetLengthMethod(MethodDeclarationSyntax methodDeclaration) { return GetStatementSyntaxs(methodDeclaration).Count(); }
private static IEnumerable<StatementSyntax> GetStatementSyntaxs(MethodDeclarationSyntax method) { return method.DescendantNodes() .OfType<StatementSyntax>() .Where(statement => !(statement is BlockSyntax)); }
public void Add(MethodDeclarationSyntax node) { FlatArrayBuilder fab = new FlatArrayBuilder(); MethodSymbol s = Chunk.Model.GetDeclaredSymbol(node); fab.Add(FlatValue.Int32(s.IsStatic ? (int)ClassMemberType.StaticMethod : (int)ClassMemberType.Method)); fab.Add(FlatValue.String(s.GetFullyQualifiedName())); MethodSymbol ms = Chunk.Model.GetDeclaredSymbol(node); Function f; if (!Chunk.Functions.TryGetValue(ms, out f)) { throw new NotImplementedException("Method not found " + ms.ToString()); } fab.Add(FlatValue.Int32(f.NumFunction)); Members.Add(fab.GetFlatValue()); }
public void AddFunction(MethodDeclarationSyntax node) { int nFunction = FunctionsByNumber.Count; Function f = new Function(this,nFunction, Model, Model.GetDeclaredSymbol(node)); Functions.Add(f.MethodSymbol, f); FunctionsByNumber.Add(f); }
public string Generate(Interface interf) { var importDeclarations = ImportNamespaceDeclarations(); var namespaceDeclarations = new List <SyntaxNode>(); foreach (var typedef in interf.Typedefs) { if (typedef.Kind == TypeKind.Struct) { AddClassType(namespaceDeclarations, interf, typedef); } else if (typedef.Kind == TypeKind.Enum) { AddEnumType(namespaceDeclarations, interf, typedef); } else { throw new NotSupportedException(); } } List <MemberDeclarationSyntax> classDeclarations = new List <MemberDeclarationSyntax>(); // InterfaceName var interfaceAddressField = SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration( SyntaxFactory.PredefinedType( SyntaxFactory.Token(SyntaxKind.StringKeyword))) .WithVariables( SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>( SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier("InterfaceName")) .WithInitializer( SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(interf.Name))))))) .WithModifiers( SyntaxFactory.TokenList( new [] { SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.ConstKeyword) })); classDeclarations.Add(interfaceAddressField); string[] splitName = interf.Name.Split('.').Select(name => $"{char.ToUpper(name[0])}{name.Substring(1)}").ToArray(); string className = splitName[splitName.Length - 1]; string namespaceName = string.Join('.', splitName.Take(splitName.Length - 1)); // _conn field var connField = SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration( SyntaxFactory.IdentifierName("IConnection")) .WithVariables( SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>( SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier("_conn"))))) .WithModifiers( SyntaxFactory.TokenList( new [] { SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword) })); classDeclarations.Add(connField); // ctor var constructor = SyntaxFactory.ConstructorDeclaration( SyntaxFactory.Identifier(className)) .WithModifiers( SyntaxFactory.TokenList( SyntaxFactory.Token(SyntaxKind.PublicKeyword))) .WithParameterList( SyntaxFactory.ParameterList( SyntaxFactory.SingletonSeparatedList <ParameterSyntax>( SyntaxFactory.Parameter( SyntaxFactory.Identifier("address")) .WithType( SyntaxFactory.PredefinedType( SyntaxFactory.Token(SyntaxKind.StringKeyword)))))) .WithBody( SyntaxFactory.Block( SyntaxFactory.SingletonList <StatementSyntax>( SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName("_conn"), SyntaxFactory.ObjectCreationExpression( SyntaxFactory.IdentifierName("Connection")) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>( SyntaxFactory.Argument( SyntaxFactory.IdentifierName("address")))))))))); classDeclarations.Add(constructor); foreach (var method in interf.Methods) { string methodBody = "return _conn.CallAsync"; TypeSyntax returnType; if (method.ReturnType.Members.Count > 0) { method.ReturnType.Name = $"{method.Name}Result"; AddClassType(namespaceDeclarations, interf, method.ReturnType); returnType = SyntaxFactory.ParseTypeName($"Task<{method.ReturnType.Name}>"); methodBody += $"<{method.ReturnType.Name}>"; } else { returnType = SyntaxFactory.ParseTypeName("System.Threading.Task"); } methodBody += $"(\"{interf.Name}.{method.Name}\", GetErrorParametersType"; SeparatedSyntaxList <ParameterSyntax> parameters = new SeparatedSyntaxList <ParameterSyntax>(); if (method.ParameterType.Members.Count > 0) { method.ParameterType.Name = $"{method.Name}Args"; AddClassType(namespaceDeclarations, interf, method.ParameterType); parameters = parameters.Add(SyntaxFactory.Parameter(SyntaxFactory.Identifier("args")).WithType(SyntaxFactory.ParseTypeName(method.ParameterType.Name))); methodBody += ", args);"; } else { methodBody += ");"; } MethodDeclarationSyntax newMethod = SyntaxFactory.MethodDeclaration( SyntaxFactory.List <AttributeListSyntax>(), SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), returnType, null, SyntaxFactory.Identifier($"{method.Name}Async"), null, SyntaxFactory.ParameterList(parameters), SyntaxFactory.List <TypeParameterConstraintClauseSyntax>(), SyntaxFactory.Block(SyntaxFactory.ParseStatement(methodBody)), SyntaxFactory.Token(SyntaxKind.SemicolonToken) ); classDeclarations.Add(newMethod); } // GetErrorParametersType var getErrorParametersTypeMethod = SyntaxFactory.MethodDeclaration( SyntaxFactory.QualifiedName( SyntaxFactory.IdentifierName("System"), SyntaxFactory.IdentifierName("Type")), SyntaxFactory.Identifier("GetErrorParametersType")) .WithModifiers( SyntaxFactory.TokenList( new [] { SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword) })) .WithParameterList( SyntaxFactory.ParameterList( SyntaxFactory.SingletonSeparatedList <ParameterSyntax>( SyntaxFactory.Parameter( SyntaxFactory.Identifier("args")) .WithType( SyntaxFactory.PredefinedType( SyntaxFactory.Token(SyntaxKind.StringKeyword)))))) // TODO: generate body .WithBody( SyntaxFactory.Block( SyntaxFactory.SingletonList <StatementSyntax>( SyntaxFactory.ReturnStatement( SyntaxFactory.LiteralExpression( SyntaxKind.NullLiteralExpression))))); classDeclarations.Add(getErrorParametersTypeMethod); // TODO: generate error name const string members // dispose method var disposeMethod = SyntaxFactory.MethodDeclaration( SyntaxFactory.PredefinedType( SyntaxFactory.Token(SyntaxKind.VoidKeyword)), SyntaxFactory.Identifier("Dispose")) .WithModifiers( SyntaxFactory.TokenList( SyntaxFactory.Token(SyntaxKind.PublicKeyword))) .WithBody( SyntaxFactory.Block( SyntaxFactory.SingletonList <StatementSyntax>( SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("_conn"), SyntaxFactory.IdentifierName("Dispose"))))))); classDeclarations.Add(disposeMethod); namespaceDeclarations.Add( SyntaxFactory.ClassDeclaration(className) .WithBaseList( SyntaxFactory.BaseList( SyntaxFactory.SingletonSeparatedList <BaseTypeSyntax>( SyntaxFactory.SimpleBaseType( SyntaxFactory.IdentifierName("IDisposable"))))) .WithMembers( SyntaxFactory.List <MemberDeclarationSyntax>(classDeclarations)) ); var namespaceDeclaration = _generator.NamespaceDeclaration(_generator.DottedName(namespaceName), namespaceDeclarations); var compilationUnit = _generator.CompilationUnit(importDeclarations.Concat(new[] { namespaceDeclaration })); return(compilationUnit.NormalizeWhitespace().ToFullString()); }
public CodeAction(IDocument document, MethodDeclarationSyntax method) { _document = document; _method = method; }
void CompileVertexSignature(MethodDeclarationSyntax method) { var ParameterList = method.ParameterList.Parameters; if (ParameterList.Count == 0) return; var first = ParameterList.First(); var last = ParameterList.Last(); foreach (var parameter in ParameterList) { if (parameter == first) continue; CompileVertexParameter(parameter); EndLine(); } }
/// <summary> /// Initializes a new instance of the <see cref="MethodDeclaration"/> class. /// </summary> /// <param name="methodDeclarationNode"></param> public MethodDeclaration(MethodDeclarationSyntax methodDeclarationNode) : this(methodDeclarationNode, null) { }
private MethodMetadata ExtractMethodMetadata(MethodDeclarationSyntax node, TypeMetadata parentType) { var methodName = node.Identifier.Text; return(new MethodMetadata(methodName, parentType)); }
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) { return base.VisitMethodDeclaration(node); }
/// <summary> /// Initializes a new instance of the <see cref="MethodDeclaration"/> class. /// </summary> /// <param name="methodDeclarationNode"></param> /// <param name="semanticModel"></param> public MethodDeclaration(MethodDeclarationSyntax methodDeclarationNode, SemanticModel semanticModel) : base(methodDeclarationNode, semanticModel) { this.parameters = null; }
private static void HandleMethod(ISemanticModel sema, MethodDeclarationSyntax method) { Console.WriteLine("\t" + method.Identifier.ValueText); HandleStatements(method); HandleConditions(method); HandleMethodLength(method); HandleDeclarations(method); HandleInvocations(sema, method); HandleConstructorInvocations(sema, method); }
public string CompileShader(NamedTypeSymbol Symbol, MethodDeclarationSyntax vertex_method, MethodDeclarationSyntax fragment_method) { ClearString(); // Declare samplers and other relevant structures needed for the Fragment Shader Write(SpaceFormat(FileBegin)); EndLine(); WriteLine(); WriteLine(VertexMethodParameters); CompileVertexSignature(vertex_method); EndLine(); WriteLine(FragmentMethodParameters); var LocalFragmentLookup = CompileFragmentSignature(fragment_method); EndLine(); // Referenced foreign variables Write(SpaceFormat(ReferencedForeignVarsPreamble)); EndLine(); Write("<$0$>"); // This is where we will insert referenced foreign variables. WriteLine(); // Referenced methods Write(SpaceFormat(ReferencedMethodsPreamble)); EndLine(); Write("<$1$>"); // This is where we will insert referenced methods. WriteLine(); // Vertex Shader method CurrentMethod = Compiling.VertexMethod; Write(SpaceFormat(VertexShaderBegin)); EndLine(); var PrevIndent = Indent(); FunctionParameterPrefix = VertexShaderParameterPrefix; CompileStatement(vertex_method.Body); RestoreIndent(PrevIndent); Write(SpaceFormat(VertexShaderEnd)); EndLine(); WriteLine(); // Fragment Shader method UseLocalSymbolMap(LocalFragmentLookup); CurrentMethod = Compiling.FragmentMethod; Write(FragmentShaderBegin, Tab, LineBreak, VertexToPixelDecl); EndLine(); PrevIndent = Indent(); FunctionParameterPrefix = FragmentShaderParameterPrefix; CompileStatement(fragment_method.Body); RestoreIndent(PrevIndent); Write(SpaceFormat(FragmentShaderEnd)); EndLine(); UseLocalSymbolMap(null); WriteLine(); Write(SpaceFormat(FileEnd)); // We must wait until after compiling the shader to know which methods that shader references. string methods = GetReferencedMethods(); // We must wait until after compiling the shader to know which foreign variables that shader references. string foreign_vars = GetForeignVars(); // Now get the full string written so far and insert the referenced methods. string fragment = GetString(); fragment = SpecialFormat(fragment, foreign_vars, methods); return fragment; }
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) { if (node.Span.Equals(declaration.Span)) { // Use method analyzer to add the return value and change the return RefactoringType. var methodAnalyzer = AnalyzerFactory.GetMethodDeclarationAnalyzer(); methodAnalyzer.SetMethodDeclaration(node); methodAnalyzer.ChangeReturnValue(returnSymbolName); return methodAnalyzer.ChangeReturnType(returnSymbolType); } return node; }
Dictionary<Symbol, string> CompileFragmentSignature(MethodDeclarationSyntax method) { var SignatureMap = new Dictionary<Symbol, string>(specialization); var ParameterList = method.ParameterList.Parameters; if (ParameterList.Count == 0) return SignatureMap; var first = ParameterList.First(); var last = ParameterList.Last(); foreach (var parameter in ParameterList) { var symbol = GetSymbol(parameter); // The first parameter must be a VertexOut, which maps to "psin" if (parameter == first) { SignatureMap.Add(symbol, "psin"); continue; } // Skip specialization values bool specialized = SignatureMap.ContainsKey(symbol); CompileFragmentParameter(parameter, specialized); if (!specialized) { EndLine(); if (parameter != last) { WriteLine(); } } } return SignatureMap; }
/// <summary> /// Create a single ui element pointing to a method /// </summary> /// <param name="textView">Editor</param> /// <param name="totalLines">Number of lines in the file</param> /// <param name="lineNumber">Line number where the method start</param> /// <param name="method">current method</param> private void CreateMethodTick(IWpfTextView textView, int totalLines, int lineNumber, MethodDeclarationSyntax method) { if (textView.ViewportHeight == 0) return; double ratio = (double)lineNumber / (double)totalLines; double yPos = ratio * textView.ViewportHeight; double newYPos = Math.Ceiling(yPos); Grid rect = new Grid(); rect.MouseLeftButtonDown += new System.Windows.Input.MouseButtonEventHandler(rect_MouseLeftButtonDown); string tooltipMessage = method.ToString(); if(tooltipMessage.Replace(Environment.NewLine, "\r").Count(f => f == '\r') > 5) { tooltipMessage = ConvertStringArrayToString(tooltipMessage.Replace(Environment.NewLine, "\r").Split('\r'), 5); tooltipMessage += Environment.NewLine + "..."; } rect.ToolTip = tooltipMessage; rect.Tag = method; rect.Background = new SolidColorBrush(Colors.LightGreen); rect.VerticalAlignment = System.Windows.VerticalAlignment.Top; rect.HorizontalAlignment = System.Windows.HorizontalAlignment.Left; rect.Margin = new System.Windows.Thickness(0, newYPos, 0, 0); rect.Height = textView.ViewportHeight / (double)totalLines; if (rect.Height < height) rect.Height = height; rect.Width = width; this.Children.Add(rect); }
private string GetExerciseCode(MethodDeclarationSyntax method) { var codeLines = method.TransformExercise().ToPrettyString().SplitToLines(); return(string.Join("\n", FilterSpecialComments(codeLines))); }