private INamespaceOrTypeSymbol GetContainer(TypeInfo typeInfo, SymbolInfo symbolInfo) { INamespaceOrTypeSymbol container = null; if (typeInfo.Type != null) { container = typeInfo.Type; } else if (symbolInfo.Symbol is INamespaceSymbol) { container = (INamespaceSymbol)symbolInfo.Symbol; } else if (symbolInfo.Symbol is IMethodSymbol) { ITypeSymbol returnType = ((IMethodSymbol)symbolInfo.Symbol).ReturnType; container = returnType; } else if (symbolInfo.Symbol is INamedTypeSymbol) { var namedType = ((INamedTypeSymbol)symbolInfo.Symbol); container = namedType.OriginalDefinition; } return(container); }
public string GetCallTipTextAtPosition(string code, int position) { SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(code); var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); var compilation = CSharpCompilation.Create("output", options: options) .AddSyntaxTrees(syntaxTree) .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(typeof(MongoSharpTextWriter).Assembly.Location), MetadataReference.CreateFromFile(typeof(IEnumerable <int>).Assembly.Location), MetadataReference.CreateFromFile(typeof(IQueryable).Assembly.Location), MetadataReference.CreateFromFile(typeof(MongoDB.Bson.BsonDocument).Assembly.Location), MetadataReference.CreateFromFile(typeof(MongoDB.Driver.MongoCollection).Assembly.Location), MetadataReference.CreateFromFile(typeof(MongoDB.Driver.MongoClient).Assembly.Location) ); var semanticModel = compilation.GetSemanticModel(syntaxTree); SyntaxToken token = syntaxTree.GetRoot().FindToken(position); SyntaxNode identifier = token.Parent; SymbolInfo symbolInfo = semanticModel.GetSymbolInfo(identifier); TypeInfo typeInfo = semanticModel.GetTypeInfo(identifier); ITypeSymbol typeSymbol = typeInfo.Type; if (typeSymbol == null && symbolInfo.Symbol != null && symbolInfo.Symbol is ITypeSymbol) { typeSymbol = (ITypeSymbol)symbolInfo.Symbol.OriginalDefinition; } var err = (from e in semanticModel.GetDiagnostics() where (e.Severity == DiagnosticSeverity.Error || e.Severity == DiagnosticSeverity.Info) && position >= e.Location.SourceSpan.Start && position <= (e.Location.SourceSpan.Start + e.Location.SourceSpan.Length) select e.ToString()).ToList(); if (err.Any()) { return(err[0]); } if (typeSymbol != null) { string xmlComments = new XmlCommentsHelper().GetTypeComments(typeSymbol); string symbolName = symbolInfo.Symbol == null ? "" : symbolInfo.Symbol.Name + " "; string callTip = typeSymbol.ToString() + " " + symbolName + Environment.NewLine + " " + xmlComments; callTip = callTip.TrimEnd(new[] { ' ', '\t', '\n' }); return(Environment.NewLine + " " + callTip + " " + Environment.NewLine); } else if (symbolInfo.Symbol is IMethodSymbol) { var method = ((IMethodSymbol)symbolInfo.Symbol); string xmlComments = new XmlCommentsHelper().GetMethodComments(method); string callTip = method.ReturnType.Name + " " + symbolInfo.Symbol.ToDisplayString() + Environment.NewLine + " " + xmlComments; callTip = callTip.TrimEnd(new[] { ' ', '\t', '\n' }); return(Environment.NewLine + " " + callTip + " " + Environment.NewLine); } return(null); }
private void AnalyzeInvocation(SyntaxNodeAnalysisContext context) { InvocationExpressionSyntax expressionSyntax = (InvocationExpressionSyntax)context.Node; if (!(expressionSyntax.Expression is MemberAccessExpressionSyntax expression)) { return; } if (expression.Name.Identifier.ValueText != "ToString") { return; } TypeInfo type = context.SemanticModel.GetTypeInfo(expression.Expression); if (IsItAlreadyObject(type, context)) { return; } if (HasToStringOverride(type, context)) { return; } Location loc = expression.GetLocation(); context.ReportDiagnostic(Diagnostic.Create(Rule, loc)); }
public async Task <(IReadOnlyCollection <(VariableDeclarationSyntax Decl, ITypeSymbol Type)> Variables, IReadOnlyCollection <CSharpSyntaxNode> Methods)> SplitVariableDeclarationsAsync( VariableDeclaratorSyntax declarator, HashSet <ILocalSymbol> symbolsToSkip = null, bool preferExplicitType = false) { var vbInitValue = GetInitializerToConvert(declarator); var initializerOrMethodDecl = await vbInitValue.AcceptAsync(TriviaConvertingExpressionVisitor); var vbInitializerTypeInfo = vbInitValue != null?_semanticModel.GetTypeInfo(vbInitValue) : default(TypeInfo?); var vbInitializerType = vbInitValue != null ? vbInitializerTypeInfo.Value.Type : default(ITypeSymbol); bool requireExplicitTypeForAll = declarator.Names.Count > 1; IMethodSymbol initSymbol = null; if (vbInitValue != null) { TypeInfo expType = vbInitializerTypeInfo.Value; preferExplicitType |= ShouldPreferExplicitType(vbInitValue, expType.ConvertedType, out bool vbInitIsNothingLiteral); initSymbol = _semanticModel.GetSymbolInfo(vbInitValue).Symbol as IMethodSymbol; bool isAnonymousFunction = initSymbol?.IsAnonymousFunction() == true; requireExplicitTypeForAll |= vbInitIsNothingLiteral || isAnonymousFunction; } var csVars = new Dictionary <string, (VariableDeclarationSyntax Decl, ITypeSymbol Type)>(); var csMethods = new List <CSharpSyntaxNode>(); foreach (var name in declarator.Names) { var declaredSymbol = _semanticModel.GetDeclaredSymbol(name); if (symbolsToSkip?.Contains(declaredSymbol) == true) { continue; } var declaredSymbolType = declaredSymbol.GetSymbolType(); var equalsValueClauseSyntax = await ConvertEqualsValueClauseSyntaxAsync(declarator, name, vbInitValue, declaredSymbolType, declaredSymbol, initializerOrMethodDecl); var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax); string k = declaredSymbolType?.GetFullMetadataName() ?? name.ToString();//Use likely unique key if the type symbol isn't available if (csVars.TryGetValue(k, out var decl)) { csVars[k] = (decl.Decl.AddVariables(v), decl.Type); continue; } if (initializerOrMethodDecl == null || initializerOrMethodDecl is ExpressionSyntax) { var variableDeclaration = CreateVariableDeclaration(declarator, preferExplicitType, requireExplicitTypeForAll, vbInitializerType, declaredSymbolType, equalsValueClauseSyntax, initSymbol, v); csVars[k] = (variableDeclaration, declaredSymbolType); } else { csMethods.Add(initializerOrMethodDecl); } } return(csVars.Values, csMethods); }
private Boolean IsItAlreadyObject(TypeInfo type, SyntaxNodeAnalysisContext context) { if (type.Type.Equals(context.SemanticModel.Compilation.GetTypeByMetadataName(typeof(Object).FullName))) { return(true); } return(false); }
private List <IMethodSymbol> GetTypeToStringMethods(TypeInfo type) { return(type .Type .GetMembers("ToString") .Where(k => k is IMethodSymbol) .OfType <IMethodSymbol>() .Where(k => k.IsOverride && k.Kind == SymbolKind.Method) .ToList()); }
private Boolean HasToStringOverride(TypeInfo type, SyntaxNodeAnalysisContext context) { var toStringMethod = GetTypeToStringMethods(type); if (toStringMethod.Any()) { if (!IsToStringIsShadow(toStringMethod, context)) { return(true); } } return(false); }
public string GetCallTipTextAtPosition(string code, int position) { var syntaxTree = CSharpSyntaxTree.ParseText(code); var semanticModel = GenerateSemanticModel(syntaxTree); SyntaxToken token = syntaxTree.GetRoot().FindToken(position); SyntaxNode identifier = token.Parent; SymbolInfo symbolInfo = semanticModel.GetSymbolInfo(identifier); TypeInfo typeInfo = semanticModel.GetTypeInfo(identifier); ITypeSymbol typeSymbol = typeInfo.Type; if (typeSymbol == null && symbolInfo.Symbol != null && symbolInfo.Symbol is ITypeSymbol) { typeSymbol = (ITypeSymbol)symbolInfo.Symbol.OriginalDefinition; } var err = (from e in semanticModel.GetDiagnostics() where (e.Severity == DiagnosticSeverity.Error || e.Severity == DiagnosticSeverity.Info) && position >= e.Location.SourceSpan.Start && position <= (e.Location.SourceSpan.Start + e.Location.SourceSpan.Length) select e.ToString()).ToList(); if (err.Any()) { return(err[0]); } if (typeSymbol != null) { string xmlComments = new XmlCommentsHelper().GetTypeComments(typeSymbol); string symbolName = symbolInfo.Symbol == null ? "" : symbolInfo.Symbol.Name + " "; string callTip = typeSymbol.ToString() + " " + symbolName + Environment.NewLine + " " + xmlComments; callTip = callTip.TrimEnd(new[] { ' ', '\t', '\n' }); return(Environment.NewLine + " " + callTip + " " + Environment.NewLine); } else if (symbolInfo.Symbol is IMethodSymbol) { var method = ((IMethodSymbol)symbolInfo.Symbol); string xmlComments = new XmlCommentsHelper().GetMethodComments(method); string callTip = method.ReturnType.Name + " " + symbolInfo.Symbol.ToDisplayString() + Environment.NewLine + " " + xmlComments; callTip = callTip.TrimEnd(new[] { ' ', '\t', '\n' }); return(Environment.NewLine + " " + callTip + " " + Environment.NewLine); } return(null); }
public List <string> GetCompletionListAtPosition(string source, int position) { SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source); var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); var compilation = CSharpCompilation.Create("output", options: options) .AddSyntaxTrees(syntaxTree) .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(typeof(MongoSharpTextWriter).Assembly.Location), MetadataReference.CreateFromFile(typeof(IEnumerable <int>).Assembly.Location), MetadataReference.CreateFromFile(typeof(IQueryable).Assembly.Location), MetadataReference.CreateFromFile(typeof(MongoDB.Bson.BsonDocument).Assembly.Location), MetadataReference.CreateFromFile(typeof(MongoDB.Driver.MongoCollection).Assembly.Location), MetadataReference.CreateFromFile(typeof(MongoDB.Driver.MongoClient).Assembly.Location) ); var semanticModel = compilation.GetSemanticModel(syntaxTree); //position += 2; SyntaxToken token = syntaxTree.GetRoot().FindToken(position); SyntaxNode identifier = token.Parent; if (identifier is ArgumentListSyntax) { identifier = identifier.Parent; } TypeInfo typeInfo = semanticModel.GetTypeInfo(identifier); SymbolInfo symbolInfo = semanticModel.GetSymbolInfo(identifier); INamespaceOrTypeSymbol container = GetContainer(typeInfo, symbolInfo); ImmutableArray <ISymbol> symbols = semanticModel.LookupSymbols(position, container, includeReducedExtensionMethods: container is ITypeSymbol); var results = new List <string>(); var sb = new StringBuilder(); foreach (ISymbol symbol in symbols.Where(x => (x.DeclaredAccessibility == Accessibility.Public || x.DeclaredAccessibility == Accessibility.NotApplicable) /*&& !x.IsStatic*/)) { sb.AppendLine(symbol.DeclaredAccessibility + " " + symbol.Kind + ": " + symbol.ToDisplayString()); string symbolName = symbol.Name.Replace('\r', ' ').Replace('\n', ' ').Replace(" ", ""); if (symbol is IMethodSymbol) { if (((IMethodSymbol)symbol).IsGenericMethod) { symbolName += "<>"; } if (((IMethodSymbol)symbol).IsExtensionMethod) { symbolName += "?0"; } else { symbolName += "?1"; } } else if (symbol is IPropertySymbol) { symbolName += "?2"; } results.Add(symbolName); } results = results.Distinct().OrderBy(x => x).ToList(); return(results); }
public List<T> Parse<T>(string codeFilePath, string methodName, int paramsCount) { string sCodeLocation = codeFilePath; string sCodeText = File.ReadAllText(sCodeLocation, Encoding.UTF8); FileInfo CSProjFile = null; #region Find project file. FileInfo codeFileInfo = new FileInfo(sCodeLocation); FileInfo[] projFileInfos = codeFileInfo.Directory.GetFiles("*.csproj", SearchOption.TopDirectoryOnly); projFileInfos = projFileInfos.Where((projFileInfo) => { if (Regex.IsMatch(projFileInfo.FullName, ".*[.]csproj$")) { return true; } return false; }).ToArray(); DirectoryInfo parentFolder = null; int iDeepth = 0; while (!projFileInfos.Any()) { iDeepth++; parentFolder = codeFileInfo.Directory.Parent; projFileInfos = codeFileInfo.Directory.GetFiles("*.csproj", SearchOption.TopDirectoryOnly); projFileInfos = projFileInfos.Where((projFileInfo) => { if (Regex.IsMatch(projFileInfo.FullName, ".*[.]csproj$")) { return true; } return false; }).ToArray(); if (iDeepth > 3 && codeFileInfo.Directory.GetFiles("*.sln", SearchOption.TopDirectoryOnly).Any()) { break; } } if (projFileInfos.Any()) { CSProjFile = projFileInfos[0]; } else { throw new FileNotFoundException(string.Format("Can't found the project configuration file. Code file {0}.", codeFilePath)); } #endregion #region Get all references references = new List<ReferenceInfo>(); XDocument xdocCSProj = XDocument.Load(CSProjFile.FullName); string sXmlns = xdocCSProj.Root.Attribute(XName.Get("xmlns")).Value; List<XElement> refNodes = xdocCSProj.Root.Descendants().Where((xe) => { if (xe.Name.LocalName == "Reference") { return true; } return false; }).ToList(); ReferenceInfo refInfo = null; foreach (XElement refNode in refNodes) { refInfo = new ReferenceInfo(); refInfo.IsProjectReference = false; refInfo.IsTeamCode = true; refInfo.Name = refNode.Attribute(XName.Get("Include")).Value; if (refNode.HasElements) { refInfo.AssemblyLocationForDebug = refNode.Element(XName.Get("HintPath", sXmlns)).Value; refInfo.AssemblyLocationForDebug = Path.Combine(CSProjFile.Directory.FullName, refInfo.AssemblyLocationForDebug); refInfo.AssemblyLocationForRelease = refNode.Element(XName.Get("HintPath", sXmlns)).Value; refInfo.AssemblyLocationForRelease = Path.Combine(CSProjFile.Directory.FullName, refInfo.AssemblyLocationForDebug); } if (refInfo.AssemblyLocationForDebug == null) { refInfo.AssemblyName = refInfo.Name; refInfo.AssemblyLocationForDebug = refInfo.Name; refInfo.AssemblyLocationForRelease = refInfo.Name; } if (!File.Exists(refInfo.Name)) { refInfo.IsTeamCode = false; } else { refInfo.LoadedAssembly = Assembly.LoadFile(refInfo.AssemblyLocationForRelease); } references.Add(refInfo); } refNodes = xdocCSProj.Root.Descendants().Where((xe) => { if (xe.Name.LocalName == "ProjectReference") { return true; } return false; }).ToList(); FileInfo refProjFileInfo = null; XDocument xdocRefProjFile = null; string sRefCSProjXmlns = string.Empty; XElement CSProjInfoNode = null; foreach (XElement refNode in refNodes) { refInfo = new ReferenceInfo(); refInfo.IsProjectReference = true; refInfo.IsTeamCode = true; refInfo.Name = refNode.Attribute(XName.Get("Include")).Value; refProjFileInfo = new FileInfo(Path.Combine(CSProjFile.Directory.FullName, refInfo.Name)); xdocRefProjFile = XDocument.Load(refProjFileInfo.FullName); sRefCSProjXmlns = xdocRefProjFile.Root.Attribute(XName.Get("xmlns")).Value; CSProjInfoNode = xdocRefProjFile.Root.Descendants(XName.Get("AssemblyName", sRefCSProjXmlns)).FirstOrDefault(); if (CSProjInfoNode != null) { refInfo.AssemblyName = CSProjInfoNode.Value; } CSProjInfoNode = xdocRefProjFile.Root.Descendants(XName.Get("Configuration", sRefCSProjXmlns)).FirstOrDefault(); if (CSProjInfoNode.Value == "Debug") { #region For Debug CSProjInfoNode = xdocRefProjFile.Root.Descendants(XName.Get("PropertyGroup", sRefCSProjXmlns)) .Where(xe => { try { if (xe.Attribute(XName.Get("Condition")).Value.Contains("Debug")) { return true; } } catch { } return false; }) .FirstOrDefault(); CSProjInfoNode = CSProjInfoNode != null ? CSProjInfoNode.Descendants(XName.Get("OutputPath", sRefCSProjXmlns)).FirstOrDefault() : null; if (CSProjInfoNode != null) { refInfo.AssemblyLocationForDebug = CSProjInfoNode.Value; refInfo.AssemblyLocationForDebug = Path.Combine(refProjFileInfo.Directory.FullName, refInfo.AssemblyLocationForDebug); if (!refInfo.AssemblyLocationForDebug.EndsWith(refInfo.AssemblyName + ".dll")) { refInfo.AssemblyLocationForDebug = Path.Combine(refInfo.AssemblyLocationForDebug, refInfo.AssemblyName + ".dll"); } } #endregion } else { #region For Release CSProjInfoNode = xdocRefProjFile.Root.Descendants(XName.Get("PropertyGroup", sRefCSProjXmlns)) .Where(xe => { try { if (xe.Attribute(XName.Get("Condition")).Value.Contains("Release")) { return true; } } catch { } return false; }) .FirstOrDefault(); CSProjInfoNode = CSProjInfoNode != null ? CSProjInfoNode.Descendants(XName.Get("OutputPath", sRefCSProjXmlns)).FirstOrDefault() : null; if (CSProjInfoNode != null) { refInfo.AssemblyLocationForRelease = CSProjInfoNode.Value; refInfo.AssemblyLocationForRelease = Path.Combine(refProjFileInfo.Directory.FullName, refInfo.AssemblyLocationForRelease); if (!refInfo.AssemblyLocationForRelease.EndsWith(refInfo.AssemblyName + ".dll")) { refInfo.AssemblyLocationForRelease = Path.Combine(refInfo.AssemblyLocationForRelease, refInfo.AssemblyName + ".dll"); } } #endregion } refInfo.Name = refNode.Element(XName.Get("Name", sXmlns)).Value; if (File.Exists(refInfo.Name)) { refInfo.IsTeamCode = false; } else { refInfo.LoadedAssembly = Assembly.LoadFile((refInfo.AssemblyLocationForDebug != null) ? refInfo.AssemblyLocationForDebug : refInfo.AssemblyLocationForRelease); } references.Add(refInfo); } #endregion CSharpCompilationOptions co = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); List<SyntaxTree> trees = new List<SyntaxTree>(); trees.Add(CSharpSyntaxTree.ParseText(sCodeText)); CSharpCompilation compilation = CSharpCompilation.Create(@"Roslyn_Output.dll" , options: co , syntaxTrees: trees); #region Add reference metadata to compiler. MetadataReference mr = null; foreach (ReferenceInfo RI in references) { if (File.Exists(RI.AssemblyLocationForDebug)) { if (string.IsNullOrEmpty(RI.AssemblyLocationForRelease)) { mr = MetadataReference.CreateFromFile(RI.AssemblyLocationForDebug, properties: MetadataReferenceProperties.Assembly); } else { mr = MetadataReference.CreateFromFile(RI.AssemblyLocationForDebug, properties: MetadataReferenceProperties.Assembly); } } RI.CurrentReferenceMetadata = mr; compilation = compilation.AddReferences(RI.CurrentReferenceMetadata); } #endregion #region create compilation unit and SemanticModel semanticModel = compilation.GetSemanticModel(trees[0]); CompilationUnitSyntax compilationUnit = trees[0].GetCompilationUnitRoot(); this.usings = compilationUnit.Usings; NamespaceDeclarationSyntax namespaceDeclaration = compilationUnit.Members .OfType<NamespaceDeclarationSyntax>().FirstOrDefault(); ClassDeclarationSyntax classDeclaration = namespaceDeclaration.Members .OfType<ClassDeclarationSyntax>().FirstOrDefault(); MethodDeclarationSyntax methodDeclaration = classDeclaration.Members .OfType<MethodDeclarationSyntax>() .Where(mds => string.Equals(mds.Identifier.ValueText, methodName) && mds.ParameterList.Parameters.Count >= paramsCount) .FirstOrDefault(); ParameterSyntax parameter = methodDeclaration.ParameterList.Parameters[0]; #endregion //(methodDeclaration.Body.Statements[1] as StatementSyntax); //MethodSymbol members = semanticModel.GetDeclaredSymbol(methodDeclaration); //// (line - column) information - start at 0. //string lcInfo = members.Locations[0].GetLineSpan(true).ToString(); //Symbol symbolAt44 = semanticModel.LookupSymbols(compilationUnit.DescendantTokens().ToArray()[44].FullSpan.End).FirstOrDefault(); List<InvocationExpressionSyntax> methodCalls = methodDeclaration.Body.DescendantNodes() .OfType<InvocationExpressionSyntax>().ToList(); string sMethodName = (methodCalls[3].Expression as MemberAccessExpressionSyntax).GetLastToken().ValueText; ExpressionSyntax es0 = methodDeclaration .FindToken((methodCalls[3] as InvocationExpressionSyntax).Expression.FullSpan.Start) .Parent as ExpressionSyntax; string varType0 = es0.Kind().ToString();// IdentifierName if (es0.Kind() == SyntaxKind.IdentifierName) { SyntaxToken[] callSeq = (methodCalls[3].Expression as MemberAccessExpressionSyntax).DescendantTokens() .Where(st => { if (st.Kind() == SyntaxKind.IdentifierToken) { return true; } return false; }).ToArray(); SymbolInfo symbolInfo0 = semanticModel.GetSymbolInfo(es0); Microsoft.CodeAnalysis.TypeInfo ti = semanticModel.GetTypeInfo(es0); string sVariableTypeName = ti.Type.Name; // first token type name. cpb1 Type tCPB = SearchTypeInAllAssemblies(sVariableTypeName); MemberInfo memberInfo = null; Type sNextType = null; int iSearchStart = 1; for (; iSearchStart < callSeq.Length; iSearchStart++) { memberInfo = tCPB.GetMembers() .Where(mi => { if (string.Equals(mi.Name, callSeq[iSearchStart].ValueText)) { return true; } return false; }) .FirstOrDefault(); if (memberInfo != null) { switch (memberInfo.MemberType) { case MemberTypes.Field: sNextType = (memberInfo as FieldInfo).FieldType; break; case MemberTypes.Property: sNextType = (memberInfo as PropertyInfo).PropertyType; break; case MemberTypes.Method: sNextType = (memberInfo as MethodInfo).ReturnType; break; } tCPB = sNextType; sNextType = null; } else { break; } } // Most possibility is extension method. if (memberInfo == null) { } MethodInfo target = memberInfo as MethodInfo; } foreach (ReferenceInfo RI in references.Where(e => e.LoadedAssembly != null)) { RI.LoadedAssembly = null; } return null; }
public SymbolResult LookupSymbols(string source, int pos, char c) { var result = new SymbolResult(); SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source); var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); var compilation = CSharpCompilation.Create("output", options: options) .AddSyntaxTrees(syntaxTree) .AddReferences(new MetadataFileReference(typeof(object).Assembly.Location), new MetadataFileReference(typeof(MongoSharpTextWriter).Assembly.Location), new MetadataFileReference(typeof(IEnumerable <int>).Assembly.Location), new MetadataFileReference(typeof(IQueryable).Assembly.Location), new MetadataFileReference(typeof(MongoDB.Bson.BsonDocument).Assembly.Location), new MetadataFileReference(typeof(MongoDB.Driver.MongoCollection).Assembly.Location)); SemanticModel semanticModel = compilation.GetSemanticModel(syntaxTree); if (c == '.') { SyntaxToken syntaxToken = syntaxTree.GetRoot().FindToken(pos - 2); SyntaxNode syntaxNode = syntaxToken.Parent; if (syntaxNode is ArgumentListSyntax) { syntaxNode = syntaxNode.Parent; } TypeInfo typeInfo = semanticModel.GetTypeInfo(syntaxNode); SymbolInfo symbolInfo = semanticModel.GetSymbolInfo(syntaxNode); INamespaceOrTypeSymbol container = GetContainer(typeInfo, symbolInfo); ImmutableArray <ISymbol> symbols = semanticModel.LookupSymbols(pos - 2, container, includeReducedExtensionMethods: container is ITypeSymbol); result.Symbols.AddRange(symbols.ToList()); } else if (c == '(') { SyntaxToken token = syntaxTree.GetRoot().FindToken(pos - 2); SyntaxNode identifier = token.Parent; ArgumentListSyntax arglist = null; if (identifier is ArgumentListSyntax) { arglist = identifier as ArgumentListSyntax; identifier = identifier.Parent; } var symbolInfo = semanticModel.GetSymbolInfo(identifier); if (symbolInfo.CandidateReason == CandidateReason.OverloadResolutionFailure && symbolInfo.CandidateSymbols.Length > 0 && symbolInfo.CandidateSymbols[0].Kind == SymbolKind.Method) { if (arglist != null) { List <ArgumentSyntax> args = arglist.Arguments.ToList(); var ex = args[0].Expression; } var methodSymbol = ((IMethodSymbol)symbolInfo.CandidateSymbols[0]); result.MethodInfos.AddRange(GetMethodInfos(methodSymbol).ConvertAll(x => new MethodResult { MethodInfo = x })); } else if (symbolInfo.Symbol is IMethodSymbol) { var methodSymbol = ((IMethodSymbol)symbolInfo.Symbol); result.MethodInfos.AddRange(GetMethodInfos(methodSymbol).ConvertAll(x => new MethodResult { MethodInfo = x })); } else if (symbolInfo.Symbol is ITypeSymbol) { var typeSymbol = symbolInfo.Symbol as ITypeSymbol; result.ConstructorInfos.AddRange(GetConstructorInfos(typeSymbol).ConvertAll(x => new ConstructorResult { ConstructorInfo = x })); } } else { } return(result); }
public SymbolResult LookupSymbols(string source, int pos, char c) { var result = new SymbolResult(); var syntaxTree = CSharpSyntaxTree.ParseText(source); var semanticModel = GenerateSemanticModel(syntaxTree); if (c == '.') { SyntaxToken syntaxToken = syntaxTree.GetRoot().FindToken(pos - 2); SyntaxNode syntaxNode = syntaxToken.Parent; if (syntaxNode is ArgumentListSyntax) { syntaxNode = syntaxNode.Parent; } TypeInfo typeInfo = semanticModel.GetTypeInfo(syntaxNode); SymbolInfo symbolInfo = semanticModel.GetSymbolInfo(syntaxNode); INamespaceOrTypeSymbol container = GetContainer(typeInfo, symbolInfo); ImmutableArray <ISymbol> symbols = semanticModel.LookupSymbols(pos - 2, container, includeReducedExtensionMethods: container is ITypeSymbol); result.Symbols.AddRange(symbols.ToList()); } else if (c == '(') { SyntaxToken token = syntaxTree.GetRoot().FindToken(pos - 2); SyntaxNode identifier = token.Parent; ArgumentListSyntax arglist = null; if (identifier is ArgumentListSyntax) { arglist = identifier as ArgumentListSyntax; identifier = identifier.Parent; } var symbolInfo = semanticModel.GetSymbolInfo(identifier); if (symbolInfo.CandidateReason == CandidateReason.OverloadResolutionFailure && symbolInfo.CandidateSymbols.Length > 0 && symbolInfo.CandidateSymbols[0].Kind == SymbolKind.Method) { if (arglist != null) { List <ArgumentSyntax> args = arglist.Arguments.ToList(); var ex = args[0].Expression; } var methodSymbol = ((IMethodSymbol)symbolInfo.CandidateSymbols[0]); result.MethodInfos.AddRange(GetMethodInfos(methodSymbol).ConvertAll(x => new MethodResult { MethodInfo = x })); } else if (symbolInfo.Symbol is IMethodSymbol) { var methodSymbol = ((IMethodSymbol)symbolInfo.Symbol); result.MethodInfos.AddRange(GetMethodInfos(methodSymbol).ConvertAll(x => new MethodResult { MethodInfo = x })); } else if (symbolInfo.Symbol is ITypeSymbol) { var typeSymbol = symbolInfo.Symbol as ITypeSymbol; result.ConstructorInfos.AddRange(GetConstructorInfos(typeSymbol).ConvertAll(x => new ConstructorResult { ConstructorInfo = x })); } } else { } return(result); }
public static AnnotatedType GetAnnotatedTypeForConverted(this TypeInfo typeInfo) => new AnnotatedType(typeInfo.ConvertedType);
public static AnnotatedType GetAnnotatedType(this TypeInfo typeInfo) => new AnnotatedType(typeInfo.Type);
public static string GetFullName(this TypeInfo typeInfo) { return(typeInfo.ConvertedType.GetFullName()); }
public static CSharpCompilation RemapDynamicVariables(CSharpCompilation cs) { var sem = cs.GetSemanticModel(systree, true); var node = systree.GetRoot(); var vars = node.DescendantNodes() .OfType <LocalDeclarationStatementSyntax>() .ToArray(); for (int i = 0; i < vars.Count(); i++) { LocalDeclarationStatementSyntax lds = vars[i]; VariableDeclaratorSyntax vds = lds.Declaration.Variables.First(); Microsoft.CodeAnalysis.TypeInfo initInformation = sem.GetTypeInfo(vds.Initializer.Value); var varType = lds.Declaration.Type; var _returnType = SyntaxFactory.IdentifierName (initInformation.Type.Name + " "); // For the sb.replace var returnType = SyntaxFactory.IdentifierName (initInformation.Type.Name); if (initInformation.Type.TypeKind == TypeKind.Array) { continue; } else if (initInformation.Type.Name.Equals("List")) { continue; } var _newDec = lds.ReplaceNode(varType, _returnType); // For the sb.replace var newDec = lds.ReplaceNode(varType, returnType); var newRt = node.ReplaceNode(lds, newDec); string base1 = lds.ToFullString().Replace("\n", "").Trim(); string base2 = _newDec.ToFullString().Replace("\n", "").Trim(); sb = sb.Replace(base1, base2); node = newRt; SyntaxTree oldTree = cs.SyntaxTrees[0]; SyntaxTree newTree = node.SyntaxTree; cs = cs.ReplaceSyntaxTree(oldTree, newTree); sem = cs.GetSemanticModel(newTree); vars = node.DescendantNodes() .OfType <LocalDeclarationStatementSyntax>() .ToArray(); } var newsys = systree.WithRootAndOptions(node, new CSharpParseOptions()); systree = newsys; Program.WriteCode(sb.ToString()); return(CSharpCompilation.Create( cs.AssemblyName, new[] { systree }, cs.References, cs.Options)); }