protected override async Task <ISymbol> GetSymbol(Document document, int tokenPosition, CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var syntaxTree = await semanticModel.SyntaxTree.GetRootAsync(cancellationToken);
var token = syntaxTree.FindToken(tokenPosition);
if (token.Parent is MethodDeclarationSyntax m)
{
return(ModelExtensions.GetDeclaredSymbol(semanticModel, m, cancellationToken));
}
if (token.Parent is ClassDeclarationSyntax c)
{
return(ModelExtensions.GetDeclaredSymbol(semanticModel, c, cancellationToken));
}
if (token.Parent is StructDeclarationSyntax s)
{
return(ModelExtensions.GetDeclaredSymbol(semanticModel, s, cancellationToken));
}
return(null);
}
public AsyncClassGenerator(Compilation compilation, MethodDeclarationSyntax node)
{
this.compilation = compilation;
this.node = node;
method = (IMethodSymbol)ModelExtensions.GetDeclaredSymbol(compilation.GetSemanticModel(node.SyntaxTree), node);
}
protected override object VisitInterfaceDeclaration(InterfaceDeclarationSyntax node)
{
var aaa = ModelExtensions.GetDeclaredSymbol(context.RoslynModel, node);
var name = _Name(node.Identifier);
context.ClassNames.Push(name);
try
{
var fulName = state.Context.CurrentNamespace + "." + name;
state.CurrentType = context.KnownTypes.Where(i => i.FullName == fulName).FirstOrDefault();
try
{
var statements1 = Visit(node.Members);
var wrong = statements1.Where(i => !(i is IClassMember)).ToArray();
if (wrong.Any())
{
throw new Exception(wrong[0].GetType().FullName);
}
return(new InterfaceDeclaration(name, statements1.Cast <IClassMember>().ToArray()));
}
finally
{
state.CurrentType = null;
}
}
finally
{
context.ClassNames.Pop();
}
}
protected override object VisitClassDeclaration(ClassDeclarationSyntax node)
{
// MemberDeclarationSyntax
var aaa = ModelExtensions.GetDeclaredSymbol(context.RoslynModel, node);
// var literalInfo = model.GetTypeInfo(helloWorldString);
//if (context.ClassNames.Count != 0)
// throw new NotSupportedException("Nested class");
var name = _Name(node.Identifier);
context.ClassNames.Push(name);
try
{
var fulName = state.Context.CurrentNamespace + "." + name;
state.CurrentType = context.KnownTypes.Where(i => i.FullName == fulName).FirstOrDefault();
try
{
var statements1 = Visit(node.Members);
var wrong = statements1.Where(i => !(i is IClassMember)).ToArray();
if (wrong.Any())
{
throw new Exception(wrong[0].GetType().FullName);
}
return(new ClassDeclaration(name, statements1.Cast <IClassMember>().ToArray()));
}
finally
{
state.CurrentType = null;
}
}
finally
{
context.ClassNames.Pop();
}
}
public void Execute(GeneratorExecutionContext context)
{
context.AddSource("ReadonlyStructCenerator.cs", SourceText.From(attributeSource, Encoding.UTF8));
if (context.SyntaxReceiver is not SyntaxReceiver receiver)
{
return;
}
var options = (context.Compilation as CSharpCompilation).SyntaxTrees[0].Options as CSharpParseOptions;
var compilation = context.Compilation.AddSyntaxTrees(
CSharpSyntaxTree.ParseText(SourceText.From(attributeSource, Encoding.UTF8), options));
var attributeSymbol = compilation.GetTypeByMetadataName("ReadonlyStructGenerator.ReadonlyStructAttribute");
foreach (var candidate in receiver.CandidateStructs)
{
var model = compilation.GetSemanticModel(candidate.SyntaxTree);
var typeSymbol = ModelExtensions.GetDeclaredSymbol(model, candidate);
var attribute = typeSymbol.GetAttributes().FirstOrDefault(ad =>
ad.AttributeClass.Equals(attributeSymbol, SymbolEqualityComparer.Default));
if (attribute is null)
{
continue;
}
var namespaceName = typeSymbol.ContainingNamespace.ToDisplayString();
var structName = typeSymbol.Name;
var properties = candidate.Members
.OfType <PropertyDeclarationSyntax>()
.Where(prop => prop.AccessorList?.Accessors.Any(acc => acc.Kind() == SyntaxKind.InitAccessorDeclaration) ?? false)
.Select(prop => new { Type = prop.Type.ToString(), Name = prop.Identifier.Text });
var isConstructorDeclared = candidate.Members.Any(mem => mem.Kind() == SyntaxKind.ConstructorDeclaration);
var sb = new StringBuilder();
internal static void Execute(
string valueType,
string hintName,
string metaDataName,
string attributeText,
GeneratorExecutionContext context)
{
context.AddSource(hintName, SourceText.From(attributeText, Encoding.UTF8));
if (!(context.SyntaxReceiver is SyntaxReceiver receiver))
{
return;
}
var options = (context.Compilation as CSharpCompilation).SyntaxTrees[0].Options as CSharpParseOptions;
var compilation = context.Compilation.AddSyntaxTrees(
CSharpSyntaxTree.ParseText(SourceText.From(attributeText, Encoding.UTF8), options));
var attributeSymbol = compilation.GetTypeByMetadataName(metaDataName);
foreach (var candidate in receiver.CandidateTypes)
{
var model = compilation.GetSemanticModel(candidate.typeDeclarationSyntax.SyntaxTree);
var typeSymbol = ModelExtensions.GetDeclaredSymbol(model, candidate.typeDeclarationSyntax);
if (typeSymbol.GetAttributes().Any(ad =>
ad.AttributeClass.Equals(attributeSymbol, SymbolEqualityComparer.Default)))
{
var classSource = ProcessType(valueType, typeSymbol, attributeSymbol, candidate.isStruct);
context.AddSource(
$"{typeSymbol.ContainingNamespace.ToDisplayString()}_{typeSymbol.Name}_value_object",
SourceText.From(classSource, Encoding.UTF8));
}
}
}
/// <summary>
/// Returns a method symbol for the specified local function syntax.
/// </summary>
/// <param name="semanticModel"></param>
/// <param name="localFunction"></param>
/// <param name="cancellationToken"></param>
internal static IMethodSymbol GetDeclaredSymbol(
this SemanticModel semanticModel,
LocalFunctionStatementSyntax localFunction,
CancellationToken cancellationToken = default)
{
return((IMethodSymbol)ModelExtensions.GetDeclaredSymbol(semanticModel, localFunction, cancellationToken));
}
public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
visitingConstant = node.Modifiers.Any(SyntaxKind.ConstKeyword);
if (visitingConstant)
{
base.VisitFieldDeclaration(node);
return;
}
foreach (var variable in node.Declaration.Variables)
{
var symbol = (IFieldSymbol)ModelExtensions.GetDeclaredSymbol(model, variable);
var fullName = symbol.ToString();
if (!substitutions.ContainsKey(fullName))
{
continue;
}
if (FieldSubstitution.Qualifies(symbol))
{
result.Add(variable, new FieldSubstitution(variable, symbol, substitutions[fullName]));
}
}
base.VisitFieldDeclaration(node);
visitingConstant = false;
}
public IEnumerable <INamedTypeSymbol> GetAllCommandsImplementingInterface(Compilation currentCompilation)
{
var commands = new List <INamedTypeSymbol>();
foreach (var @class in _classes)
{
var semanticModel = currentCompilation.GetSemanticModel(@class.SyntaxTree);
var declaredSymbol = ModelExtensions.GetDeclaredSymbol(semanticModel, @class) as INamedTypeSymbol;
var interfaces = declaredSymbol.Interfaces;
var commandInterfaces = GetCommandInterfaces(currentCompilation);
if (declaredSymbol.Interfaces.Any(x =>
{
return(commandInterfaces.Any(@interface =>
SymbolEqualityComparer.Default.Equals(x.ConstructedFrom, @interface)));
}))
{
commands.Add(declaredSymbol);
}
}
return(commands);
}
public void Execute(GeneratorExecutionContext context)
{
if (context.SyntaxReceiver is not SyntaxReceiver receiver)
{
return;
}
foreach (var candidate in receiver.CandidateTypes)
{
var model = context.Compilation.GetSemanticModel(candidate.SyntaxTree);
var typeSymbol = ModelExtensions.GetDeclaredSymbol(model, candidate);
var attributeSymbol = context.Compilation.GetTypeByMetadataName("Radix.AliasAttribute`1");
var attributes = typeSymbol.GetAttributes().Where(attribute => attribute.AttributeClass.Name.Equals(attributeSymbol.Name));
foreach (var attribute in attributes)
{
var classSource = ProcessType(attribute.AttributeClass.TypeArguments.First().Name, typeSymbol, candidate);
// fix text formating according to default ruleset
var normalizedSourceCodeText
= CSharpSyntaxTree.ParseText(classSource).GetRoot().NormalizeWhitespace().GetText(Encoding.UTF8);
context.AddSource(
$"{typeSymbol.ContainingNamespace.ToDisplayString()}_{typeSymbol.Name}_alias",
normalizedSourceCodeText);
}
}
}
protected override object VisitMethodDeclaration(MethodDeclarationSyntax node)
{
// FunctionDeclarationParameter[] Parameters;
var doc = DeclarationItemDescription.Parse(node);
//if (doc != null)
// throw new NotSupportedException();
var methodSymbol = (IMethodSymbol)ModelExtensions.GetDeclaredSymbol(context.RoslynModel, node);
var mi = context.Roslyn_ResolveMethod(methodSymbol) as MethodInfo;
if (mi == null)
{
throw new NotSupportedException();
}
#warning 'Zarejestrować nazwy parametrów'
var body = Visit(node.Body) as IStatement;
return(new MethodDeclaration(mi, body));
#if OLD
Parameters = rVisit(methodSymbol.Parameters.AsEnumerable());
//var rrt = methodSymbol.ReturnType;
//var aaaa = context.RoslynCompilation.GetTypeByMetadataName(rrt.Name);
//var fullTypeName = methodSymbol.ReturnType.ToDisplayString();
//// LangType rt = new LangType();
//var hhh = methodSymbol.Parameters.ToArray();
var name = _Name(node.Identifier);
var mod = VisitModifiers(node.Modifiers);
var rt = _ResolveLangType(node.ReturnType);
//var p1 = Visit(node.ParameterList);
// var Parameters = Visit(node.ParameterList) as FunctionDeclarationParameter[];
var old = context.Arguments.ToArray();
context.Arguments.AddRange(Parameters);
context.Arguments = old.ToList();
return(new MethodDeclaration(
name,
mod,
rt,
Parameters,
body));
throw new NotImplementedException();
#endif
}
public YieldClassGenerator(Compilation compilation, ClassDeclarationSyntax classDeclarationSyntax, MemberDeclarationSyntax node)
{
this.compilation = compilation;
this.classDeclarationSyntax = classDeclarationSyntax;
this.node = node;
method = ModelExtensions.GetDeclaredSymbol(compilation.GetSemanticModel(node.SyntaxTree), node);
}
public static ISymbol GetDeclaredSymbol(this FieldDeclarationSyntax node, SemanticModel model)
{
ISymbol symbol = (
from syntax in node.Declaration.Variables
select ModelExtensions.GetDeclaredSymbol(model, syntax, new CancellationToken())).FirstOrDefault <ISymbol>();
return(symbol);
}
private bool HasCallers(MethodDeclarationSyntax methodDeclaration)
{
SemanticModel model = compilation.GetSemanticModel(syntaxTree);
IMethodSymbol methodSymbol = ModelExtensions.GetDeclaredSymbol(model, methodDeclaration) as IMethodSymbol;
IEnumerable <SymbolCallerInfo> callers = SymbolFinder.FindCallersAsync(methodSymbol, solution).GetAwaiter().GetResult();
return(callers.Any());
}
public static IEnumerable <IFieldSymbol> Fields(this IEnumerable <FieldDeclarationSyntax> fields,
Compilation compilation)
{
return(fields.SelectMany(field => {
SemanticModel model = compilation.GetSemanticModel(field.SyntaxTree);
return field.Declaration.Variables
.Select(variable => ModelExtensions.GetDeclaredSymbol(model, variable) as IFieldSymbol);
}));
}
public override void VisitForStatement(ForStatementSyntax node)
{
// Convert the variable declaration to an assignment expression statement
if (node.Declaration != null)
{
foreach (var variable in node.Declaration.Variables)
{
// Hoist the variable into a field
var symbol = (ILocalSymbol)ModelExtensions.GetDeclaredSymbol(Transformer.Model, variable);
var identifier = HoistVariable(new LiftedVariableKey(variable.Identifier, symbol));
if (variable.Initializer != null)
{
var assignment = identifier.GetReference().Assign((JsExpression)variable.Initializer.Value.Accept(Transformer));
CurrentState.Add(assignment.Express());
}
}
}
else if (node.Initializers.Any())
{
foreach (var initializer in node.Initializers)
{
var assignment = (JsExpression)initializer.Accept(Transformer);
CurrentState.Add(assignment.Express());
}
}
var topOfLoop = GetNextState();
GotoState(topOfLoop);
CurrentState = topOfLoop;
var afterLoop = GetNextState();
var bodyState = NewState();
var incrementorState = NewState();
var newWhileStatement = Js.While(
node.Condition == null ? Js.Primitive(true) : (JsExpression)node.Condition.Accept(Transformer),
GotoStateBlock(bodyState));
CurrentState.Add(newWhileStatement);
GotoState(afterLoop);
CurrentState = bodyState;
AcceptStatement(node.Statement, afterLoop, incrementorState);
GotoState(incrementorState);
CurrentState = incrementorState;
foreach (var incrementor in node.Incrementors)
{
CurrentState.Add(((JsExpression)incrementor.Accept(Transformer)).Express());
}
GotoState(topOfLoop);
CurrentState = afterLoop;
}
public static ITypeSymbol GetContainingType(this SyntaxNode node)
{
var classDeclaration = node.FirstAncestorOrSelf <ClassDeclarationSyntax>(x => true);
if (classDeclaration == null)
{
return(null);
}
return((ITypeSymbol)ModelExtensions.GetDeclaredSymbol(Context.Compilation.GetSemanticModel(classDeclaration.SyntaxTree), classDeclaration));
}
private MethodDeclarationSyntax RewriteMethodAsyncWithCancellationToken(MethodDeclarationSyntax inMethodSyntax, SemanticModel semanticModel)
{
var inMethodSymbol = (IMethodSymbol)ModelExtensions.GetDeclaredSymbol(semanticModel, inMethodSyntax);
var outMethodName = inMethodSyntax.Identifier.Text + "Async";
var rewriter = new MethodInvocationRewriter(this.log, semanticModel, this.excludedTypes, this.cancellationTokenSymbol);
var method = (MethodDeclarationSyntax)rewriter.Visit(inMethodSyntax);
method = method
.WithIdentifier(SyntaxFactory.Identifier(outMethodName))
.WithAttributeLists(new SyntaxList <AttributeListSyntax>())
.WithModifiers(inMethodSyntax.Modifiers.Add(SyntaxFactory.Token(SyntaxKind.AsyncKeyword)))
.WithParameterList(SyntaxFactory.ParameterList(inMethodSyntax.ParameterList.Parameters.Insert
(
inMethodSyntax.ParameterList.Parameters.TakeWhile(p => p.Default == null && !p.Modifiers.Any(m => m.IsKind(SyntaxKind.ParamsKeyword))).Count(),
SyntaxFactory.Parameter
(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(),
SyntaxFactory.ParseTypeName("CancellationToken"),
SyntaxFactory.Identifier("cancellationToken"),
null
)
)));
var returnType = inMethodSyntax.ReturnType.ToString();
method = method.WithReturnType(SyntaxFactory.ParseTypeName(returnType == "void" ? "Task" : $"Task<{returnType}>"));
var parentContainsAsyncMethod = this.GetAllMembers(inMethodSymbol.ReceiverType.BaseType).Any(c => c.Name == outMethodName);
var parentContainsMethodWithRewriteAsync = this.GetAllMembers(inMethodSymbol.ReceiverType.BaseType)
.Where(c => c.Name == inMethodSyntax.Identifier.Text)
.Any(m => m.GetAttributes().Any(a => a.AttributeClass.Name.Contains("RewriteAsync")));
if (!(parentContainsAsyncMethod || parentContainsMethodWithRewriteAsync))
{
method = method.WithModifiers(new SyntaxTokenList().AddRange(method.Modifiers.Where(c => c.Kind() != SyntaxKind.OverrideKeyword && c.Kind() != SyntaxKind.NewKeyword)));
}
var attribute = inMethodSymbol.GetAttributes().SingleOrDefault(a => a.AttributeClass.Name.EndsWith("RewriteAsyncAttribute"));
if (attribute?.ConstructorArguments.Length > 0)
{
if (attribute.ConstructorArguments[0].Type.Name == "MethodAttributes")
{
var methodAttributes = (MethodAttributes)Enum.ToObject(typeof(MethodAttributes), Convert.ToInt32(attribute.ConstructorArguments[0].Value));
method = method.WithAccessModifiers(methodAttributes);
}
}
return(method);
}
public static string MangleName(this BaseMethodDeclarationSyntax method, SemanticModel sm)
{
var methodSymbol = (IMethodSymbol)ModelExtensions.GetDeclaredSymbol(sm, method);
if (methodSymbol == null)
{
throw new Exception("Failled to retrieve method symbol for " + method);
}
return(methodSymbol.MangleName());
}
public void ExecuteInternal(GeneratorExecutionContext context)
{
if (!(context.SyntaxReceiver is SyntaxReceiver receiver))
{
return;
}
var compilation = context.Compilation;
var attributeSymbol = compilation.GetTypeByMetadataName("StackXML.Str.StrField");
var groupAttributeSymbol = compilation.GetTypeByMetadataName("StackXML.Str.StrOptionalAttribute");
Dictionary <INamedTypeSymbol, ClassGenInfo> classes = new Dictionary <INamedTypeSymbol, ClassGenInfo>(SymbolEqualityComparer.Default);
foreach (var field in receiver.m_candidateFields)
{
var model = compilation.GetSemanticModel(field.SyntaxTree);
foreach (var variable in field.Declaration.Variables)
{
var fieldSymbol = ModelExtensions.GetDeclaredSymbol(model, variable) as IFieldSymbol;
if (fieldSymbol == null)
{
continue;
}
var fieldAttr = fieldSymbol.GetAttributes().SingleOrDefault(ad => ad.AttributeClass.Equals(attributeSymbol, SymbolEqualityComparer.Default));
var groupAttr = fieldSymbol.GetAttributes().SingleOrDefault(ad => ad.AttributeClass.Equals(groupAttributeSymbol, SymbolEqualityComparer.Default));
if (fieldAttr == null)
{
continue;
}
if (!classes.TryGetValue(fieldSymbol.ContainingType, out var classInfo))
{
classInfo = new ClassGenInfo(fieldSymbol.ContainingType);
classes[fieldSymbol.ContainingType] = classInfo;
}
int?group = null;
if (groupAttr != null)
{
@group = (int)groupAttr.ConstructorArguments[0].Value;
}
classInfo.m_fields.Add(new FieldGenInfo(fieldSymbol, @group, variable));
}
}
foreach (KeyValuePair <INamedTypeSymbol, ClassGenInfo> info in classes)
{
var classSource = ProcessClass(info.Value.m_symbol, info.Value, classes);
context.AddSource($"{nameof(StrGenerator)}_{info.Value.m_symbol.Name}.cs", SourceText.From(classSource, Encoding.UTF8));
}
}
public int Calculate(SyntaxNode node)
{
ISymbol declaredSymbol = ModelExtensions.GetDeclaredSymbol(this.model, node, new CancellationToken());
if (declaredSymbol == null || (int)declaredSymbol.Kind != 9)
{
return(0);
}
ImmutableArray <ISymbol> members = declaredSymbol.ContainingType.GetMembers(declaredSymbol.Name);
return(members.Count <ISymbol>());
}
MethodDeclarationSyntax RewriteMethodAsync(MethodDeclarationSyntax inMethodSyntax, SemanticModel semanticModel)
{
var inMethodSymbol = (IMethodSymbol)ModelExtensions.GetDeclaredSymbol(semanticModel, inMethodSyntax);
var outMethodName = inMethodSyntax.Identifier.Text + "Async";
var methodInvocation = SyntaxFactory.InvocationExpression
(
SyntaxFactory.IdentifierName(outMethodName),
SyntaxFactory.ArgumentList
(
new SeparatedSyntaxList <ArgumentSyntax>()
.AddRange(inMethodSymbol.Parameters.TakeWhile(c => !c.HasExplicitDefaultValue).Select(c => SyntaxFactory.Argument(SyntaxFactory.IdentifierName(c.Name))))
.Add(SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("CancellationToken"), SyntaxFactory.IdentifierName("None"))))
.AddRange(inMethodSymbol.Parameters.SkipWhile(c => !c.HasExplicitDefaultValue).Skip(1).Select(c => SyntaxFactory.Argument(SyntaxFactory.IdentifierName(c.Name))))
)
);
var callAsyncWithCancellationToken = methodInvocation;
var returnType = inMethodSyntax.ReturnType.ToString();
var method = inMethodSyntax.WithBody(SyntaxFactory.Block(SyntaxFactory.ReturnStatement(callAsyncWithCancellationToken)));
method = method
.WithIdentifier(SyntaxFactory.Identifier(outMethodName))
.WithAttributeLists(new SyntaxList <AttributeListSyntax>())
.WithReturnType(SyntaxFactory.ParseTypeName(returnType == "void" ? "Task" : $"Task<{returnType}>"));
var parentContainsAsyncMethod = this.GetAllMembers(inMethodSymbol.ReceiverType.BaseType).Any(c => c.Name == outMethodName);
var parentContainsMethodWithRewriteAsync = this.GetAllMembers(inMethodSymbol.ReceiverType.BaseType)
.Where(c => c.Name == inMethodSyntax.Identifier.Text)
.Any(m => m.GetAttributes().Any(a => a.AttributeClass.Name.Contains("RewriteAsync")));
if (!(parentContainsAsyncMethod || parentContainsMethodWithRewriteAsync))
{
method = method.WithModifiers(new SyntaxTokenList().AddRange(method.Modifiers.Where(c => c.Kind() != SyntaxKind.OverrideKeyword && c.Kind() != SyntaxKind.NewKeyword)));
}
var attribute = inMethodSymbol.GetAttributes().SingleOrDefault(a => a.AttributeClass.Name.EndsWith("RewriteAsyncAttribute"));
if (attribute?.ConstructorArguments.Any() == true)
{
if (attribute.ConstructorArguments.First().Type.Name == "MethodAttributes")
{
var methodAttributes = (MethodAttributes)Enum.ToObject(typeof(MethodAttributes), Convert.ToInt32(attribute.ConstructorArguments.First().Value));
method = method.WithAccessModifiers(methodAttributes);
}
}
return(method);
}
public static bool ShouldAnalyzeSyntax(SemanticModel semanticModel, SyntaxNode node)
{
var classDecl = node.FirstAncestorOrSelf <ClassDeclarationSyntax>();
if (classDecl == null)
{
return(false);
}
var declSymbol = (INamedTypeSymbol)ModelExtensions.GetDeclaredSymbol(semanticModel, classDecl);
return(declSymbol.BaseType.Equals(semanticModel.Compilation.GetTypeByMetadataName(UdonConstants.UdonSharpBehaviourFullName), SymbolEqualityComparer.Default));
}
protected override object VisitForEachStatement(ForEachStatementSyntax node)
{
var collection = InternalVisitExpression(node.Expression);
#if ROSLYN
var info1 = ModelExtensions.GetDeclaredSymbol(context.RoslynModel, node);
var info = info1 as ILocalSymbol;
if (info == null)
{
throw new ArgumentNullException("info");
}
var rosType = context.Roslyn_ResolveType(info.Type);
var loopVariableType = new LangType(rosType);
var loopVariableName = info.Name;
#else
var type = _VisitExpression(node.Type);
if (type is UnknownIdentifierValue)
{
var xx = type as UnknownIdentifierValue;
if (xx.Identifier == "var")
{
var et = TypesUtil.GetEnumerateItemType(collection.ValueType);
type = new TypeValue(et);
}
else
{
throw new NotSupportedException();
}
}
Debug.Assert(type is TypeValue);
Debug.Assert((type as TypeValue).DotnetType == rosType);
var loopVariableType = new LangType((type as TypeValue).DotnetType);
var loopVariableName = _Name(node.Identifier);
#endif
var ps = new VariableDeclaration(
loopVariableType,
new[]
{
new VariableDeclarator(loopVariableName, null, null)
}
);
return(context.DoWithLocalVariables(ps,
() =>
{
var stat = Visit(node.Statement);
Debug.Assert(stat is IStatement);
var g = new ForEachStatement(loopVariableType, loopVariableName, collection, stat as IStatement);
return g;
}));
}
public IEnumerable <INamedTypeSymbol> GetSyncResolvers(Compilation currentCompilation)
{
// TODO: this is a complete mess
// TODO: add a class for this like we have for CommandDeclarationInfo
var resolvers = new List <INamedTypeSymbol>();
// TODO: this whole class is a mess. All of this logic should be extracted, and this should be handled by something else.
foreach (var @class in _classes)
{
var semanticModel = currentCompilation.GetSemanticModel(@class.SyntaxTree);
var declaredSymbol = ModelExtensions.GetDeclaredSymbol(semanticModel, @class) as INamedTypeSymbol;
var interfaces = declaredSymbol.Interfaces;
foreach (var @interface in interfaces)
{
var members = @interface.GetMembers();
var methods = members.OfType <IMethodSymbol>();
if (methods.Any(method => method.Name == "Resolve" && EqualParams(method.Parameters, @interface.TypeParameters)))
{
resolvers.Add(declaredSymbol);
}
}
bool EqualParams(ImmutableArray <IParameterSymbol> methodParameters, ImmutableArray <ITypeParameterSymbol> interfaceTypeParameters)
{
if (methodParameters.Length != interfaceTypeParameters.Length)
{
return(false);
}
for (var index = 0; index < methodParameters.Length; index++)
{
var methodParameter = methodParameters[index];
var interfaceGenericParameter = interfaceTypeParameters[index];
if (SymbolEqualityComparer.Default.Equals(methodParameter, interfaceGenericParameter))
{
return(false);
}
}
return(true);
}
}
return(resolvers);
}
protected override async Task <ISymbol> GetSymbol(Document document, int tokenPosition, CancellationToken cancellationToken)
{
try
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var syntaxTree = await semanticModel.SyntaxTree.GetRootAsync(cancellationToken);
var token = syntaxTree.FindToken(tokenPosition);
if (token.Parent is ClassDeclarationSyntax c)
{
return(ModelExtensions.GetDeclaredSymbol(semanticModel, c, cancellationToken));
}
var vds = token.Parent is VariableDeclarationSyntax variable
? variable
: token.Parent?.Parent as VariableDeclarationSyntax;
if (vds != null)
{
var info = semanticModel.GetSymbolInfo(vds.Type, cancellationToken);
if (info.Symbol == null || string.IsNullOrWhiteSpace(info.Symbol.ToString()))
{
return(null);
}
return(info.Symbol);
}
if (token.Parent is ParameterSyntax parameterSyntax)
{
var info = semanticModel.GetSymbolInfo(parameterSyntax.Type, cancellationToken);
if (info.Symbol == null || string.IsNullOrWhiteSpace(info.Symbol.ToString()))
{
return(null);
}
return(info.Symbol);
}
//if (_actionsSource.TryGetWordUnderCaret(out TextExtent wordExtent) && wordExtent.IsSignificant)
//{
// var text = wordExtent.Span.GetText();
// // TODO: analyze Invocation expressions, etc
//}
}
catch (Exception e)
{
Debug.WriteLine(e);
}
return(null);
}
public MethodModel(string name, List <ParameterModel> parameters, MethodDeclarationSyntax node, SemanticModel model)
: base(name, node)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
Parameters = parameters ?? new List <ParameterModel>();
IsVoid = string.Equals(node.ReturnType.ToFullString().Trim(), Strings.Generate_Method__void, StringComparison.OrdinalIgnoreCase);
if (ModelExtensions.GetDeclaredSymbol(model, node) is IMethodSymbol methodSymbol)
{
IsAsync = methodSymbol.IsAwaitableNonDynamic();
}
}
public FunctionDeclarationParameter[] rVisit(ParameterListSyntax s)
{
IParameterSymbol[] symbols = (from i in s.Parameters
let symbol = ModelExtensions.GetDeclaredSymbol(context.RoslynModel, i) as IParameterSymbol
select symbol
).ToArray();
if (symbols.Length == 0)
{
return(new FunctionDeclarationParameter[0]);
}
if (symbols.Any(i => i == null))
{
throw new Exception("Jakieś nule");
}
return(rVisit(symbols));
}
private void ValidateAsyncMethod(MethodDeclarationSyntax methodSyntax, SemanticModel semanticModel)
{
var methodSymbol = (IMethodSymbol)ModelExtensions.GetDeclaredSymbol(semanticModel, methodSyntax);
var results = AsyncMethodValidator.Validate(methodSyntax, log, this.lookup, semanticModel, excludedTypes, cancellationTokenSymbol);
if (results.Count > 0)
{
foreach (var result in results)
{
if (!result.ReplacementMethodSymbol.Equals(methodSymbol))
{
log.LogWarning($"Async method call possible in {result.Position.GetLineSpan()}");
log.LogWarning($"Replace {result.MethodInvocationSyntax.NormalizeWhitespace()} with {result.ReplacementExpressionSyntax.NormalizeWhitespace()}");
}
}
}
}
protected override object VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node)
{
var doc = DeclarationItemDescription.Parse(node);
var methodSymbol = (IMethodSymbol)ModelExtensions.GetDeclaredSymbol(context.RoslynModel, node);
var mi = context.Roslyn_ResolveMethod(methodSymbol) as MethodInfo;
if (mi == null)
{
throw new NotSupportedException();
}
#warning 'Zarejestrować nazwy parametrów'
var body = Visit(node.Body) as IStatement;
return(new MethodDeclaration(mi, body));
}
