public static string GenericName(GenericNameSyntax name) { //TODO: replace the screwed up Action<>/Func<> conversions w/ DNSwift implementations switch (name.Identifier.Text) { case "Action": //Action<string, int> converts to (String, Int) -> Void return ": (" + SyntaxNode(name.TypeArgumentList) + ") -> Void"; case "Func": //Func<string, int, string> converts to (String, Int) -> String var output = ": ("; //The last generic argument in Func<> is used as a return type var allButLastArguments = name.TypeArgumentList.Arguments.Take(name.TypeArgumentList.Arguments.Count - 1); output += string.Join(", ", allButLastArguments.Select(SyntaxNode)); return output + ") -> " + SyntaxNode(name.TypeArgumentList.Arguments.Last()); case "Unwrapped": return SyntaxNode(name.TypeArgumentList.Arguments.First()).TrimEnd('!') + "!"; case "Optional": return SyntaxNode(name.TypeArgumentList.Arguments.First()).TrimEnd('!') + "?"; case "AmbiguousWrapping": return SyntaxNode(name.TypeArgumentList.Arguments.First()).TrimEnd('!'); } //Something<another, thing> converts to Something<another, thing> :D return Type(name.Identifier.Text) + SyntaxNode(name.TypeArgumentList); }
public override SyntaxNode VisitGenericName(GenericNameSyntax node) { var typeArgument = node.ChildNodes().OfType<TypeArgumentListSyntax>(); if (typeArgument.Any()) return SyntaxFactory.IdentifierName(node.Identifier); return node; }
public override SyntaxNode VisitGenericName(GenericNameSyntax node) { if (!IsList(node)) { return base.VisitGenericName(node); } return ToArray(node); }
internal InterfaceDeclaration( string key, InterfaceDeclaration otherInterfaceDeclaration ) { Contract.Requires( !string.IsNullOrEmpty( key ) ); Contract.Requires( otherInterfaceDeclaration != null ); this.key = key; typeName = key + otherInterfaceDeclaration.DeclaredInterface.TypeArgumentList.ToString(); definingClass = otherInterfaceDeclaration.definingClass; declaredInterface = otherInterfaceDeclaration.declaredInterface; }
internal InterfaceDeclaration( ClassDeclarationSyntax definingClass, GenericNameSyntax declaredInterface ) { Contract.Requires( definingClass != null ); Contract.Requires( declaredInterface != null ); key = declaredInterface.Identifier.Text; typeName = declaredInterface.ToString(); this.definingClass = definingClass; this.declaredInterface = declaredInterface; }
public override VB.VisualBasicSyntaxNode VisitGenericName(CSS.GenericNameSyntax node) { var Identifier = VBFactory.Identifier(node.Identifier.ToString()); var TypeList = new List<VBS.TypeSyntax>(); foreach (CSS.TypeSyntax a in node.TypeArgumentList.Arguments) { VBS.TypeSyntax TypeIdentifier = (VBS.TypeSyntax)a.Accept(this); TypeList.Add(TypeIdentifier); } return VBFactory.GenericName(Identifier, VBFactory.TypeArgumentList(TypeList.ToArray())); }
private void Handle(string identifier, Location location, GenericNameSyntax genericName, SyntaxNodeAnalysisContext context) { // Leave if type is in nullable form if (genericName.IsKind(SyntaxKind.NullableType)) { return; } var genericType = context.SemanticModel.GetTypeInfo(genericName); if (genericType.Type?.MetadataName == "Nullable`1") { context.ReportDiagnostic(Diagnostic.Create(Rule, location, identifier)); } }
public static void Go(OutputWriter writer, GenericNameSyntax name) { writer.Write(WriteIdentifierName.TransformIdentifier(name.Identifier.Text)); writer.Write("!("); bool first = true; foreach (var type in name.TypeArgumentList.Arguments) { if (first) first = false; else writer.Write(", "); writer.Write(TypeProcessor.ConvertType(type)); } writer.Write(")"); }
public GenericNameTranslation(GenericNameSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { TypeArgumentList = syntax.TypeArgumentList.Get<TypeArgumentListTranslation>(this); string name = syntax.Identifier.ToString(); switch (name) { case "Func": Func = new FunctionTypeGenericNameTranslation(this); break; case "Predicate": Func = new PredicateGenericNameTranslation(this); break; case "Action": Func = new ActionTypeGenericNameTranslation(this); break; case "Comparison": Func = new ComparisonGenericNameTranslation(this); break; } }
public override void VisitGenericName(GenericNameSyntax node) { seenGeneric = true; SeparatedSyntaxList<TypeSyntax> typeArguments = node.TypeArgumentList.Arguments; if (node.IsUnboundGenericName) { if (allowedMap == null) { allowedMap = new Dictionary<GenericNameSyntax, bool>(); } allowedMap[node] = !seenConstructed; } else { seenConstructed = true; foreach (TypeSyntax arg in typeArguments) { Visit(arg); } } }
public override SyntaxNode VisitGenericName(GenericNameSyntax node) { if (node.ToString().Contains("Request")) Console.WriteLine(); if (!(node.Parent is MemberAccessExpressionSyntax) || ((MemberAccessExpressionSyntax)node.Parent).Expression == node) { if (node.GetContainingMethod() == null) { return base.VisitGenericName(node); } var containingType = node.GetContainingType(); if (containingType == null || !containingType.Name.StartsWith(enclosingTypeName)) return node; var symbol = semanticModel.GetSymbolInfo(node).Symbol; if (symbol == null || (new[] { SymbolKind.Field, SymbolKind.Event, SymbolKind.Method, SymbolKind.Property }.Contains(symbol.Kind) && !symbol.ContainingType.Name.StartsWith(enclosingTypeName) && !symbol.IsStatic)) { return SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("_this"), node); } } return base.VisitGenericName(node); }
private SyntaxNode ToArray(GenericNameSyntax node) { if (IsChangeInObjectCreation) { return node.ReplaceToken(node.Identifier, SyntaxFactory.Identifier("Array")); } var firstTypeSyntax = node.TypeArgumentList.Arguments.First(); var typeName = (TypeSyntax)new ListToArrayReplacementRewriter().Visit(firstTypeSyntax); return SyntaxFactory.ArrayType(typeName, SyntaxFactory.List(new ArrayRankSpecifierSyntax[] { SyntaxFactory.ArrayRankSpecifier() })); }
private bool IsList(GenericNameSyntax syntax) { return syntax.Identifier.ValueText == "List" || syntax.Identifier.ValueText == "IList"; }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitGenericName(GenericNameSyntax node) { this.OnNodeVisited(node); if (!this.traverseRootOnly) base.VisitGenericName(node); }
private static MethodDeclarationSyntax CreateRaiseMethod(string eventName, string eventFieldName, GenericNameSyntax argType) { var shortendEventName = eventName.Replace("On", ""); var arg = (argType.TypeArgumentList.Arguments.First() as IdentifierNameSyntax); var argTypeName = arg.Identifier.ValueText; return MethodDeclaration(arg, $"Raise{shortendEventName}") .WithModifiers(TokenList( Token(SyntaxKind.ProtectedKeyword), Token(SyntaxKind.VirtualKeyword))) .WithParameterList( ParameterList(SingletonSeparatedList<ParameterSyntax>( Parameter(Identifier(argumentName)) .WithType(IdentifierName(argTypeName)))) .WithOpenParenToken(Token(SyntaxKind.OpenParenToken)) .WithCloseParenToken(Token(SyntaxKind.CloseParenToken))) .WithBody(Block( List<StatementSyntax>( new StatementSyntax[]{ ExpressionStatement( ConditionalAccessExpression( IdentifierName(eventFieldName), InvocationExpression( MemberBindingExpression(IdentifierName(@"Invoke")) .WithOperatorToken(Token(SyntaxKind.DotToken))) .WithArgumentList(ArgumentList(SeparatedList<ArgumentSyntax>( new SyntaxNodeOrToken[]{ Argument(ThisExpression().WithToken(Token(SyntaxKind.ThisKeyword))), Token(SyntaxKind.CommaToken), Argument(IdentifierName(argumentName)) })) .WithOpenParenToken(Token(SyntaxKind.OpenParenToken)) .WithCloseParenToken(Token(SyntaxKind.CloseParenToken)))) .WithOperatorToken(Token(SyntaxKind.QuestionToken))) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)), ReturnStatement(IdentifierName(argumentName)) .WithReturnKeyword(Token(SyntaxKind.ReturnKeyword)) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)) })) .WithOpenBraceToken(Token(SyntaxKind.OpenBraceToken)) .WithCloseBraceToken(Token(SyntaxKind.CloseBraceToken))); }
protected override void GenerateInternal(Module module) { m_selectClassName = ClassNameBase + "Select"; m_whereClassName = ClassNameBase + "Where"; m_orderByClassName = ClassNameBase + "OrderBy"; var parameters = module.Parameters.ToList(); var sortParameters = RemoveAndReturnByNames(parameters, "sort", "dir"); var methodParameters = parameters.RemoveAndReturn(p => p.Required); // don't belong anywhere, are used in a special way RemoveAndReturnByNames(parameters, "continue", "offset", "limit", "prop"); var whereParameters = parameters; var selectClass = GenerateSelect(module.PropertyGroups, module.Name == "revisions"); var whereClass = GenerateWhere(whereParameters); var orderByClass = GenerateOrderBy(sortParameters, module.PropertyGroups.SelectMany(g => g.Properties)); var codeUnit = SyntaxEx.CompilationUnit( SyntaxEx.NamespaceDeclaration(Wiki.EntitiesNamespace, selectClass, whereClass, orderByClass), "System", "System.Globalization", "System.Xml.Linq", "LinqToWiki", "LinqToWiki.Collections", "LinqToWiki.Internals"); Wiki.Files.Add(ClassNameBase, codeUnit); string queryTypeName = "WikiQuery"; var queryTypeGenericParameters = new List<string> { m_whereClassName, m_selectClassName }; if (orderByClass != null) { queryTypeName += "Sortable"; queryTypeGenericParameters.Insert(1, m_orderByClassName); } if (module.Generator) { queryTypeName += "Generator"; queryTypeGenericParameters.Insert(0, Wiki.Names.Page); } m_queryType = SyntaxEx.GenericName(queryTypeName, queryTypeGenericParameters); SortType? sortType = null; var dirParameter = sortParameters.SingleOrDefault(p => p.Name == "dir"); if (dirParameter != null) { var type = (EnumParameterType)dirParameter.Type; if (type.Values.Any(x => x == "ascending")) sortType = SortType.Ascending; else if (type.Values.Any(x => x == "newer")) sortType = SortType.Newer; } GenerateMethod(module, methodParameters, m_selectClassName, m_selectProps, MethodClassName, false, sortType); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitGenericName(GenericNameSyntax node) { this.OnNodeVisited(node, this.type.IsInstanceOfType(node)); base.VisitGenericName(node); }
private bool IsArgumentListToken(GenericNameSyntax node, SyntaxToken token) { return node.TypeArgumentList != null && node.TypeArgumentList.Span.Contains(token.SpanStart) && token != node.TypeArgumentList.GreaterThanToken; }
public override SyntaxNode VisitGenericName(GenericNameSyntax node) { ISymbol symbol = this.GetSymbolOrOverloadSymbol(node); if (symbol == null) { this.AppendCompileIssue(node, IssueType.Error, IssueId.SemanticBind); } else { switch (symbol.Kind) { case SymbolKind.Method: GenerateMethodCode(node, symbol); break; default: this.AppendCompileIssue(node, IssueType.Error, IssueId.UnknownGenericName); break; } } return node; }
private static void AddTypeParameters(GenericNameSyntax genericNameSyntax, MultiDictionary<string, TypeParameterSymbol> map) { // 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 and // skipping subsequent symbols with the same name. This can result in some surprising // behavior. For example, both 'T's in "A<T>.B<T>" bind to the second implicitly // declared type parameter. SeparatedSyntaxList<TypeSyntax> typeArguments = genericNameSyntax.TypeArgumentList.Arguments; for (int i = typeArguments.Count - 1; i >= 0; i--) { // Other types (non-identifiers) are allowed in error scenarios, but they do not introduce new // cref type parameters. if (typeArguments[i].Kind() == SyntaxKind.IdentifierName) { IdentifierNameSyntax typeParameterSyntax = (IdentifierNameSyntax)typeArguments[i]; Debug.Assert(typeParameterSyntax != null, "Syntactic requirement of crefs"); string name = typeParameterSyntax.Identifier.ValueText; if (SyntaxFacts.IsValidIdentifier(name) && !map.ContainsKey(name)) { TypeParameterSymbol typeParameterSymbol = new CrefTypeParameterSymbol(name, i, typeParameterSyntax); map.Add(name, typeParameterSymbol); } } } }
public override VisualBasicSyntaxNode VisitGenericName(CSS.GenericNameSyntax node) { return(SyntaxFactory.GenericName(ConvertIdentifier(node.Identifier), (TypeArgumentListSyntax)node.TypeArgumentList.Accept(this))); }
protected override bool IsUnboundTypeAllowed(GenericNameSyntax syntax) { bool allowed; return this.allowedMap != null && this.allowedMap.TryGetValue(syntax, out allowed) && allowed; }
public static bool TryParseGenericName(this SyntaxToken genericIdentifier, CancellationToken cancellationToken, out GenericNameSyntax genericName) { if (genericIdentifier.GetNextToken(includeSkipped: true).CSharpKind() == SyntaxKind.LessThanToken) { var lastToken = genericIdentifier.FindLastTokenOfPartialGenericName(); var syntaxTree = genericIdentifier.SyntaxTree; var name = SyntaxFactory.ParseName(syntaxTree.GetText(cancellationToken).ToString(TextSpan.FromBounds(genericIdentifier.SpanStart, lastToken.Span.End))); genericName = name as GenericNameSyntax; return genericName != null; } genericName = null; return false; }
public override SyntaxNode VisitGenericName(GenericNameSyntax node) { _cancellationToken.ThrowIfCancellationRequested(); var newNode = (SimpleNameSyntax)base.VisitGenericName(node); return VisitSimpleName(newNode, node); }
public override SyntaxNode VisitGenericName(GenericNameSyntax node) { // not descending into node to simplify the whole expression return AnnotateNodeWithSimplifyAnnotation(node); }
protected override bool IsUnboundTypeAllowed(GenericNameSyntax syntax) { return false; }
public override SyntaxNode VisitGenericName(GenericNameSyntax node) { bool oldAlwaysSimplify = this.alwaysSimplify; if (!this.alwaysSimplify) { this.alwaysSimplify = node.HasAnnotation(Simplifier.Annotation); } var result = SimplifyExpression( node, newNode: base.VisitGenericName(node), simplifier: SimplifyName); this.alwaysSimplify = oldAlwaysSimplify; return result; }