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