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