public static glsl.TypeSyntax Translate(this cs.TypeSyntax node) { return(new glsl.TypeSyntax() { Name = node.ToString() }); }
public static SyntaxNode ArrayCreationExpression(this SyntaxGenerator generator, SyntaxNode type, IEnumerable <SyntaxNode> sizeExpression) { if (generator.NullLiteralExpression() is CS.ExpressionSyntax) { CS.TypeSyntax typeSyntax = type as CS.TypeSyntax; if (typeSyntax == null) { throw new ArgumentException($"Invalid syntax node type; Expected {typeof(CS.TypeSyntax).FullName}.", "type"); } IEnumerable <CS.ExpressionSyntax> csSizeExpressions = sizeExpression.Select(exp => exp as CS.ExpressionSyntax); if (csSizeExpressions.Any(exp => exp == null)) { throw new ArgumentException($"Invalid syntax node type; Expected {typeof(CS.ExpressionSyntax).FullName}.", "sizeExpression"); } return(CSSF.ArrayCreationExpression( CSSF.ArrayType( typeSyntax, CSSF.SingletonList( CSSF.ArrayRankSpecifier( CSSF.SeparatedList(csSizeExpressions) ) ) ) )); } else { throw new ArgumentException("Not a CSharp ExpressionSyntax"); } }
public static MethodDeclarationSyntax MethodDeclaration( SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax body, SyntaxToken semicolonToken) { return SyntaxFactory.MethodDeclaration( attributeLists, modifiers, default(SyntaxToken), returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses, body, default(ArrowExpressionClauseSyntax), semicolonToken); }
protected override bool TryAnalyzeVariableDeclaration(TypeSyntax typeName, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken, out TextSpan issueSpan) { issueSpan = default(TextSpan); // If it is currently not var, explicit typing exists, return. // this also takes care of cases where var is mapped to a named type via an alias or a class declaration. if (!typeName.IsTypeInferred(semanticModel)) { return false; } if (typeName.Parent.IsKind(SyntaxKind.VariableDeclaration) && typeName.Parent.Parent.IsKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.ForStatement, SyntaxKind.UsingStatement)) { // check assignment for variable declarations. var variable = ((VariableDeclarationSyntax)typeName.Parent).Variables.First(); if (!AssignmentSupportsStylePreference(variable.Identifier, typeName, variable.Initializer, semanticModel, optionSet, cancellationToken)) { return false; } } issueSpan = typeName.Span; return true; }
private static void HandleDeclaration(SyntaxNodeAnalysisContext context, TypeSyntax returnType) { var predefinedType = returnType as PredefinedTypeSyntax; if (predefinedType != null && predefinedType.Keyword.IsKind(SyntaxKind.VoidKeyword)) { // There is no return value return; } var documentationStructure = context.Node.GetDocumentationCommentTriviaSyntax(); if (documentationStructure == null) { return; } if (documentationStructure.Content.GetFirstXmlElement(XmlCommentHelper.InheritdocXmlTag) != null) { // Don't report if the documentation is inherited. return; } if (documentationStructure.Content.GetFirstXmlElement(XmlCommentHelper.ReturnsXmlTag) == null) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, returnType.GetLocation())); } }
public override SyntaxList <StatementSyntax> VisitForEachBlock(VBSyntax.ForEachBlockSyntax node) { var stmt = node.ForEachStatement; TypeSyntax type = null; SyntaxToken id; if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax) { var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable; var declaration = SplitVariableDeclarations(v, nodesVisitor, semanticModel).Values.Single(); type = declaration.Type; id = declaration.Variables[0].Identifier; } else { var v = (IdentifierNameSyntax)stmt.ControlVariable.Accept(nodesVisitor); id = v.Identifier; type = SyntaxFactory.ParseTypeName("var"); } var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this))); return(SingleStatement(SyntaxFactory.ForEachStatement( type, id, (ExpressionSyntax)stmt.Expression.Accept(nodesVisitor), block.UnpackBlock() ))); }
public static string GetTrackerClassName(TypeSyntax type) { // NOTE: it's naive approach because we don't know semantic type information here. var genericType = type as GenericNameSyntax; if (genericType == null) { if (type.ToString().StartsWith("Trackable")) { return $"TrackablePocoTracker<I{type.ToString().Substring(9)}>"; } } else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(), "TrackableData.TrackableDictionary")) { return $"TrackableDictionaryTracker{genericType.TypeArgumentList}"; } else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(), "TrackableData.TrackableSet")) { return $"TrackableSetTracker{genericType.TypeArgumentList}"; } else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(), "TrackableData.TrackableList")) { return $"TrackableListTracker{genericType.TypeArgumentList}"; } throw new Exception("Cannot resolve tracker class of " + type); }
public static bool IsTrackableType(TypeSyntax type) { // NOTE: it's naive approach because we don't know semantic type information here. var parts = type.ToString().Split('.'); var typeName = parts[parts.Length - 1]; return typeName.StartsWith("Trackable"); }
private static IEnumerable<TypeSyntax> GetAllReferencedTypes(TypeSyntax type, SyntaxNodeAnalysisContext context) { if (type == null) throw new ArgumentNullException(nameof(type)); // The "all referenced types" set will be the current type and any generic type parameters that it has (and any generic type parameters that // they might have).. yield return type; // .. so, if this type doesn't have any type parameters then we're done here.. // If this isn't var genericTypeIfApplicable = type as GenericNameSyntax; if (genericTypeIfApplicable == null) yield break; // .. alternatively, if the type has the Bridge [IgnoreGeneric] attribute on it then we don't need to worry about the type parameters since // there won't be references to them at runtime var typeSymbolInfo = context.SemanticModel.GetSymbolInfo(type); if ((typeSymbolInfo.Symbol != null) && typeSymbolInfo.Symbol.GetAttributes().Any(attribute => IsBridgeClass(attribute.AttributeClass, "IgnoreGenericAttribute"))) yield break; foreach (var typeParameter in genericTypeIfApplicable.TypeArgumentList.Arguments) { foreach (var typeRelatedToTypeParameter in GetAllReferencedTypes(typeParameter, context)) yield return typeRelatedToTypeParameter; } }
private void AddTypeParameters(TypeSyntax typeSyntax, MultiDictionary<string, TypeParameterSymbol> map) { switch (typeSyntax.Kind()) { case SyntaxKind.AliasQualifiedName: AddTypeParameters(((AliasQualifiedNameSyntax)typeSyntax).Name, map); break; case SyntaxKind.QualifiedName: // NOTE: Dev11 does not warn about duplication, it just matches parameter types to the // *last* type parameter with the same name. That's why we're iterating backwards. QualifiedNameSyntax qualifiedNameSyntax = (QualifiedNameSyntax)typeSyntax; AddTypeParameters(qualifiedNameSyntax.Right, map); AddTypeParameters(qualifiedNameSyntax.Left, map); break; case SyntaxKind.GenericName: AddTypeParameters((GenericNameSyntax)typeSyntax, map); break; case SyntaxKind.IdentifierName: case SyntaxKind.PredefinedType: break; default: Debug.Assert(false, "Unexpected type syntax kind " + typeSyntax.Kind()); break; } }
public MethodDeclarationSyntax BuildDeclaration(TypeSyntax returnType, string name, IEnumerable<ParameterSyntax> paramsInfo) { MethodDeclarationSyntax mDecl = SF.MethodDeclaration (returnType, name); mDecl = mDecl.AddModifiers (SF.Token (SyntaxKind.PublicKeyword)); mDecl = mDecl.AddParameterListParameters (paramsInfo.ToArray ()); return mDecl; }
public static SourceLocalSymbol MakeForeachLocal( MethodSymbol containingMethod, ForEachLoopBinder binder, TypeSyntax typeSyntax, SyntaxToken identifierToken, ExpressionSyntax collection) { return new SourceLocalSymbol(containingMethod, binder, typeSyntax, identifierToken, null, collection, LocalDeclarationKind.ForEach); }
public FurnaceTypeWriter(string baseClassFullName) { GuardBaseClass(baseClassFullName); var typeIndex = baseClassFullName.LastIndexOf('.') + 1; _typeName = baseClassFullName.Substring(typeIndex); _typeNamespace = baseClassFullName.Substring(0, typeIndex - 1); _baseTypeSyntax = SyntaxFactory.ParseTypeName(baseClassFullName); }
internal static Document PerformAction(Document document, SyntaxNode root, TypeSyntax type) { var newRoot = root.ReplaceNode((SyntaxNode) type, SyntaxFactory.IdentifierName("var") .WithLeadingTrivia(type.GetLeadingTrivia()) .WithTrailingTrivia(type.GetTrailingTrivia()) ); return document.WithSyntaxRoot(newRoot); }
internal static PropertyDeclarationSyntax CreateAutoProperty(TypeSyntax type, string identifier, SyntaxList<AccessorDeclarationSyntax> accessors, SyntaxKind? accessibility) { var newProperty = SyntaxFactory.PropertyDeclaration(type, identifier) .WithAccessorList(SyntaxFactory.AccessorList(accessors)); if (accessibility.HasValue) newProperty = newProperty.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(accessibility.Value))); return newProperty.WithAdditionalAnnotations(Formatter.Annotation); }
public static SourceLocalSymbol MakeLocal( Symbol containingSymbol, Binder binder, TypeSyntax typeSyntax, SyntaxToken identifierToken, LocalDeclarationKind declarationKind) { Debug.Assert(declarationKind != LocalDeclarationKind.ForEachIterationVariable); return new SourceLocalSymbol(containingSymbol, binder, typeSyntax, identifierToken, declarationKind); }
static Document PerformAction(Document document, SemanticModel model, SyntaxNode root, ITypeSymbol type, TypeSyntax typeSyntax) { var newRoot = root.ReplaceNode((SyntaxNode) typeSyntax, SyntaxFactory.ParseTypeName(type.ToMinimalDisplayString(model, typeSyntax.SpanStart)) .WithLeadingTrivia(typeSyntax.GetLeadingTrivia()) .WithTrailingTrivia(typeSyntax.GetTrailingTrivia()) ); return document.WithSyntaxRoot(newRoot); }
public static SourceLocalSymbol MakePossibleOutVarLocalWithoutInitializer( Symbol containingSymbol, Binder binder, TypeSyntax typeSyntax, SyntaxToken identifierToken, CSharpSyntaxNode scopeSegmentRoot, LocalDeclarationKind declarationKind) { Debug.Assert(declarationKind != LocalDeclarationKind.ForEachIterationVariable); return new PossibleOutVarLocalWithoutInitializer(containingSymbol, binder, typeSyntax, identifierToken, scopeSegmentRoot, declarationKind); }
protected SyntaxNode HoistVariable(CSharpSyntaxNode node, ref SyntaxToken identifier, TypeSyntax type) { if (hoistedVariables.ContainsKey(identifier.ToString())) { var newName = GenerateNewName(identifier); var newIdentifier = SyntaxFactory.Identifier(newName); identifier = newIdentifier; } hoistedVariables[identifier.ToString()] = type; return node; }
public static SourceLocalSymbol MakeLocal( MethodSymbol containingMethod, Binder binder, TypeSyntax typeSyntax, SyntaxToken identifierToken, EqualsValueClauseSyntax initializer, LocalDeclarationKind declarationKind) { Debug.Assert(declarationKind != LocalDeclarationKind.ForEach); return new SourceLocalSymbol(containingMethod, binder, typeSyntax, identifierToken, initializer, null, declarationKind); }
public static SourceLocalSymbol MakeLocalWithInitializer( Symbol containingSymbol, Binder binder, TypeSyntax typeSyntax, SyntaxToken identifierToken, EqualsValueClauseSyntax initializer, LocalDeclarationKind declarationKind) { Debug.Assert(declarationKind != LocalDeclarationKind.ForEachIterationVariable); return new LocalWithInitializer(containingSymbol, binder, typeSyntax, identifierToken, initializer, declarationKind); }
public QueryUnboundLambdaState(UnboundLambda unbound, Binder binder, RangeVariableMap rangeVariableMap, ImmutableArray<RangeVariableSymbol> parameters, ExpressionSyntax body, TypeSyntax castTypeSyntax, TypeSymbol castType) : this(unbound, binder, rangeVariableMap, parameters, (LambdaSymbol lambdaSymbol, ExecutableCodeBinder lambdaBodyBinder, DiagnosticBag diagnostics) => { BoundExpression expression = lambdaBodyBinder.BindValue(body, diagnostics, BindValueKind.RValue); Debug.Assert((object)castType != null); Debug.Assert(castTypeSyntax != null); // We transform the expression from "expr" to "expr.Cast<castTypeOpt>()". expression = lambdaBodyBinder.MakeQueryInvocation(body, expression, "Cast", castTypeSyntax, castType, diagnostics); return lambdaBodyBinder.WrapExpressionLambdaBody(expression, body, diagnostics); }) { }
internal GlobalExpressionVariable( SourceMemberContainerTypeSymbol containingType, DeclarationModifiers modifiers, TypeSyntax typeSyntax, string name, SyntaxReference syntax, Location location) : base(containingType, modifiers, name, syntax, location) { Debug.Assert(DeclaredAccessibility == Accessibility.Private); _typeSyntax = typeSyntax.GetReference(); }
/// <summary> /// Semantic model merges the symbols, but the compiled form retains multiple namespaces, which (when referenced from C#) need to keep the correct casing. /// <seealso cref="DeclarationNodeVisitor.WithDeclarationCasingAsync(VBSyntax.NamespaceBlockSyntax, ISymbol)"/> /// <seealso cref="CommonConversions.WithDeclarationCasing(SyntaxToken, ISymbol, string)"/> /// </summary> private static TypeSyntax WithDeclarationCasing(TypeSyntax syntax, ITypeSymbol typeSymbol) { var vbType = SyntaxFactory.ParseTypeName(typeSymbol.ToDisplayString()); var originalNames = vbType.DescendantNodes().OfType <CSSyntax.IdentifierNameSyntax>() .Select(i => i.ToString()).ToList(); return(syntax.ReplaceNodes(syntax.DescendantNodes().OfType <CSSyntax.IdentifierNameSyntax>(), (oldNode, n) => { var originalName = originalNames.FirstOrDefault(on => string.Equals(@on, oldNode.ToString(), StringComparison.OrdinalIgnoreCase)); return originalName != null ? SyntaxFactory.IdentifierName(originalName) : oldNode; })); }
protected void FilterType(TypeSyntax syntax) { if (syntax.IsKind(SyntaxKind.PredefinedType)) { var symbolInfo = SemanticModel.GetSymbolInfo(syntax); if ((symbolInfo.Symbol != null) && (symbolInfo.Symbol.Kind == SymbolKind.NamedType)) { var symbol = (ITypeSymbol)symbolInfo.Symbol; FilterTypeSymbol(symbol); } } }
// internal static readonly AstNode wherePatternCase1 = // new InvocationExpression( // new MemberReferenceExpression( // new InvocationExpression( // new MemberReferenceExpression(new AnyNode("target"), "Where"), // new LambdaExpression { // Parameters = { PatternHelper.NamedParameter ("param1", PatternHelper.AnyType ("paramType", true), Pattern.AnyString) }, // Body = PatternHelper.OptionalParentheses (new IsExpression(new AnyNode("expr1"), new AnyNode("type"))) // } // ), "Select"), // new LambdaExpression { // Parameters = { PatternHelper.NamedParameter ("param2", PatternHelper.AnyType ("paramType", true), Pattern.AnyString) }, // Body = PatternHelper.OptionalParentheses (new AsExpression(PatternHelper.OptionalParentheses (new AnyNode("expr2")), new Backreference("type"))) // } // ); // // internal static readonly AstNode wherePatternCase2 = // new InvocationExpression( // new MemberReferenceExpression( // new InvocationExpression( // new MemberReferenceExpression(new AnyNode("target"), "Where"), // new LambdaExpression { // Parameters = { PatternHelper.NamedParameter ("param1", PatternHelper.AnyType ("paramType", true), Pattern.AnyString) }, // Body = PatternHelper.OptionalParentheses (new IsExpression(PatternHelper.OptionalParentheses (new AnyNode("expr1")), new AnyNode("type"))) // } // ), "Select"), // new LambdaExpression { // Parameters = { PatternHelper.NamedParameter ("param2", PatternHelper.AnyType ("paramType", true), Pattern.AnyString) }, // Body = PatternHelper.OptionalParentheses (new CastExpression(new Backreference("type"), PatternHelper.OptionalParentheses (new AnyNode("expr2")))) // } // ); static bool MatchWhereSelect(InvocationExpressionSyntax selectInvoke, out ExpressionSyntax target, out TypeSyntax type) { target = null; type = null; if (selectInvoke.ArgumentList.Arguments.Count != 1) return false; var anyInvokeBase = selectInvoke.Expression as MemberAccessExpressionSyntax; if (anyInvokeBase == null || anyInvokeBase.Name.Identifier.Text != "Select") return false; var whereInvoke = anyInvokeBase.Expression as InvocationExpressionSyntax; if (whereInvoke == null || whereInvoke.ArgumentList.Arguments.Count != 1) return false; var baseMember = whereInvoke.Expression as MemberAccessExpressionSyntax; if (baseMember == null || baseMember.Name.Identifier.Text != "Where") return false; target = baseMember.Expression; ParameterSyntax param1, param2; ExpressionSyntax expr1, expr2; if (!ExtractLambda(whereInvoke.ArgumentList.Arguments[0], out param1, out expr1)) return false; if (!ExtractLambda(selectInvoke.ArgumentList.Arguments[0], out param2, out expr2)) return false; if (!expr1.IsKind(SyntaxKind.IsExpression)) return false; type = (expr1 as BinaryExpressionSyntax)?.Right as TypeSyntax; if (type == null) return false; if (expr2.IsKind(SyntaxKind.AsExpression)) { if (!CompareNames(param2, (expr2 as BinaryExpressionSyntax).Left as IdentifierNameSyntax)) return false; if (!type.IsEquivalentTo((expr2 as BinaryExpressionSyntax)?.Right)) return false; } else if (expr2.IsKind(SyntaxKind.CastExpression)) { if (!CompareNames(param2, (expr2 as CastExpressionSyntax)?.Expression.SkipParens() as IdentifierNameSyntax)) return false; if (!type.IsEquivalentTo((expr2 as CastExpressionSyntax)?.Type)) return false; } else return false; if (!CompareNames(param1, (expr1 as BinaryExpressionSyntax)?.Left as IdentifierNameSyntax)) return false; return target != null; }
public MethodDeclarationSyntax BuildExtensionMethod(TypeSyntax returnType, string name, IEnumerable<ParameterSyntax> paramsInfo) { MethodDeclarationSyntax mDecl = SF.MethodDeclaration (returnType, name); mDecl = mDecl.AddModifiers (SF.Token (SyntaxKind.PublicKeyword), SF.Token (SyntaxKind.StaticKeyword)); ParameterSyntax[] parameterSyntax = paramsInfo.ToArray (); ParameterSyntax thisParam = parameterSyntax [0]; parameterSyntax [0] = thisParam.WithModifiers (SF.TokenList ((SF.Token (SyntaxKind.ThisKeyword)))); mDecl = mDecl.AddParameterListParameters (parameterSyntax); return mDecl; }
private static void HandleDeclaration(SyntaxNodeAnalysisContext context, TypeSyntax returnType) { var predefinedType = returnType as PredefinedTypeSyntax; if (predefinedType != null && predefinedType.Keyword.IsKind(SyntaxKind.VoidKeyword)) { // There is no return value return; } var documentationStructure = context.Node.GetDocumentationCommentTriviaSyntax(); if (documentationStructure == null) { return; } if (documentationStructure.Content.GetFirstXmlElement(XmlCommentHelper.InheritdocXmlTag) != null) { // Don't report if the documentation is inherited. return; } var relevantXmlElement = documentationStructure.Content.GetFirstXmlElement(XmlCommentHelper.ReturnsXmlTag); if (relevantXmlElement != null) { // A <returns> element was located. return; } relevantXmlElement = documentationStructure.Content.GetFirstXmlElement(XmlCommentHelper.IncludeXmlTag); if (relevantXmlElement != null) { var declaration = context.SemanticModel.GetDeclaredSymbol(context.Node, context.CancellationToken); var rawDocumentation = declaration?.GetDocumentationCommentXml(expandIncludes: true, cancellationToken: context.CancellationToken); XElement completeDocumentation = XElement.Parse(rawDocumentation, LoadOptions.None); if (completeDocumentation.Nodes().OfType<XElement>().Any(element => element.Name == XmlCommentHelper.InheritdocXmlTag)) { // Ignore nodes with an <inheritdoc/> tag in the included XML. return; } if (completeDocumentation.Nodes().OfType<XElement>().Any(element => element.Name == XmlCommentHelper.ReturnsXmlTag)) { // A <returns> element was located. return; } } context.ReportDiagnostic(Diagnostic.Create(Descriptor, returnType.GetLocation())); }
private async Task<Document> ReplaceUsage( Document document, TypeSyntax type, string interfaceName, string interfaceNamespace, CancellationToken cancellationToken) { var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken) as CompilationUnitSyntax; var newRoot = syntaxRoot .ReplaceNode(type, IdentifierName(interfaceName)) .AddUsings( UsingDirective( IdentifierName(interfaceNamespace)) .WithAdditionalAnnotations(Formatter.Annotation, Simplifier.Annotation)); return document.WithSyntaxRoot(newRoot); }
protected override bool TryAnalyzeVariableDeclaration(TypeSyntax typeName, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken, out TextSpan issueSpan) { // If it is already var, return. if (typeName.IsTypeInferred(semanticModel)) { issueSpan = default(TextSpan); return false; } var candidateReplacementNode = SyntaxFactory.IdentifierName("var"); var candidateIssueSpan = typeName.Span; // If there exists a type named var, return. var conflict = semanticModel.GetSpeculativeSymbolInfo(typeName.SpanStart, candidateReplacementNode, SpeculativeBindingOption.BindAsTypeOrNamespace).Symbol; if (conflict?.IsKind(SymbolKind.NamedType) == true) { issueSpan = default(TextSpan); return false; } if (typeName.Parent.IsKind(SyntaxKind.VariableDeclaration) && typeName.Parent.IsParentKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.ForStatement, SyntaxKind.UsingStatement)) { var variableDeclaration = (VariableDeclarationSyntax)typeName.Parent; // implicitly typed variables cannot be constants. if ((variableDeclaration.Parent as LocalDeclarationStatementSyntax)?.IsConst == true) { issueSpan = default(TextSpan); return false; } var variable = variableDeclaration.Variables.Single(); if (AssignmentSupportsStylePreference( variable.Identifier, typeName, variable.Initializer.Value, semanticModel, optionSet, cancellationToken)) { issueSpan = candidateIssueSpan; return true; } } else if (typeName.IsParentKind(SyntaxKind.ForEachStatement)) { issueSpan = candidateIssueSpan; return true; } issueSpan = default(TextSpan); return false; }
public static PropertyDeclarationSyntax PropertyDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax type, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, AccessorListSyntax accessorList, ArrowExpressionClauseSyntax expressionBody, EqualsValueClauseSyntax initializer, SyntaxToken semicolonToken) { return PropertyDeclaration( attributeLists, modifiers, refKeyword: default(SyntaxToken), type: type, explicitInterfaceSpecifier: explicitInterfaceSpecifier, identifier: identifier, accessorList: accessorList, expressionBody: expressionBody, initializer: initializer, semicolonToken: semicolonToken); }
private static async Task<Location[]> FindTypeLocationsInSourceCodeAsync(Document document, TypeSyntax type, CancellationToken cancellationToken) { var result = new Location[] { }; var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var typeSymbol = semanticModel.GetSymbolInfo(type, cancellationToken).Symbol; if(typeSymbol != null) { result = typeSymbol.Locations.Where(location => location.IsInSource).ToArray(); } return result; }
public static DelegateDeclarationSyntax DelegateDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken delegateKeyword, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken semicolonToken) { return DelegateDeclaration( attributeLists, modifiers, delegateKeyword, refKeyword: default(SyntaxToken), returnType: returnType, identifier: identifier, typeParameterList: typeParameterList, parameterList: parameterList, constraintClauses: constraintClauses, semicolonToken: semicolonToken); }
private static void AppendTypeName(StringBuilder builder, TypeSyntax type) { if (type is NameSyntax) { AppendName(builder, (NameSyntax)type); } else { switch (type.Kind()) { case SyntaxKind.PredefinedType: builder.Append(((PredefinedTypeSyntax)type).Keyword.ValueText); break; case SyntaxKind.ArrayType: var arrayType = (ArrayTypeSyntax)type; AppendTypeName(builder, arrayType.ElementType); var specifiers = arrayType.RankSpecifiers; for (int i = 0; i < specifiers.Count; i++) { builder.Append('['); var specifier = specifiers[i]; if (specifier.Rank > 1) { builder.Append(',', specifier.Rank - 1); } builder.Append(']'); } break; case SyntaxKind.PointerType: AppendTypeName(builder, ((PointerTypeSyntax)type).ElementType); builder.Append('*'); break; case SyntaxKind.NullableType: AppendTypeName(builder, ((NullableTypeSyntax)type).ElementType); builder.Append('?'); break; } } }
private (TypeSyntax, ExpressionSyntax) AdjustFromName(TypeSyntax rawType, ModifiedIdentifierSyntax name, ExpressionSyntax initializer) { var type = rawType; if (!SyntaxTokenExtensions.IsKind(name.Nullable, SyntaxKind.None)) { if (type is ArrayTypeSyntax) { type = ((ArrayTypeSyntax)type).WithElementType( SyntaxFactory.NullableType(((ArrayTypeSyntax)type).ElementType)); initializer = null; } else { type = SyntaxFactory.NullableType(type); } } var rankSpecifiers = ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds, false); if (rankSpecifiers.Count > 0) { var rankSpecifiersWithSizes = ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds); if (!rankSpecifiersWithSizes.SelectMany(ars => ars.Sizes).OfType <OmittedArraySizeExpressionSyntax>().Any()) { initializer = SyntaxFactory.ArrayCreationExpression( SyntaxFactory.ArrayType(type, rankSpecifiersWithSizes)); } type = SyntaxFactory.ArrayType(type, rankSpecifiers); } return(type, initializer); }