public AnonRewriter(NamedTypeSymbol type, SemanticModel model, Compilation comp, TypeSyntax newType) { Type = type; Model = model; Comp = comp; NewType = newType; }
protected override void CompileDefaultInitialization(VariableDeclaratorSyntax declarator, TypeSyntax type) { Write("="); Write(Space); Write("("); CompileExpression(type); Write(")0"); }
public ReplaceVarByConcreteAction(ICodeActionEditFactory editFactory, IDocument document, TypeSyntax typeSyntax) { this.editFactory = editFactory; this.document = document; this.typeSyntax = typeSyntax; var semanticModel = (SemanticModel)document.GetSemanticModel(); var syntaxTree = (SyntaxTree)document.GetSyntaxTree(); ILocation location = syntaxTree.GetLocation(typeSyntax); ITypeSymbol variableType = semanticModel.GetSemanticInfo(typeSyntax).Type; this.typeName = variableType.ToMinimalDisplayString((Location)location, semanticModel); }
private SymbolInfo LookupType(BinderContext underlying, TypeSyntax type, int arity = 0) { using (var context = new DiagnosticBufferBinderContext(underlying)) { var result = context.BindType(type, arity); var err = result as ErrorTypeSymbol; if (err == null) { return new SymbolInfo(result, ConsList.Singleton(result), context.Commit(false)); } var info = err.ErrorInfo; var errors = context.Commit(false).ToList(); if (info != null) { errors.Add(new Diagnostic(info, context.Location(type))); } var syms = (info is CSDiagnosticInfo) ? (info as CSDiagnosticInfo).Symbols : Enumerable.Empty<Symbol>(); return new SymbolInfo(result, syms, errors); } }
public override SymbolInfo LookupType(TypeSyntax type, int arity = 0) { throw new NotImplementedException(); }
public SymbolInfo LookupType(TypeSyntax type, int arity = 0) { return LookupType(GetEnclosingContext(type), type, arity); }
/// <summary> /// Speculative binding: bind a type as if it appeared at a given point in the syntax /// of a program. After this has been done, /// the GetBinding methods can be used on parts of the "text" tree to get further information about /// the results of binding. /// </summary> /// <param name="location">The location where the type expression should be bound</param> /// <param name="typeName">The type name expression to be bound</param> /// <param name="arity">The arity of the type name to be bound</param> /// <returns></returns> public SymbolInfo BindType(SyntaxNode location, TypeSyntax typeName, int arity = 0) { return LookupType(GetEnclosingContext(location), typeName, arity); }
/// <summary> /// Adds a new internal class with the given name equivalent to the passed type to the given syntax tree. /// /// Sets `created` to a reference to the newly created type. /// </summary> private static SyntaxNode AddType(NamedTypeSymbol equivTo, string withName, SyntaxNode tree, out TypeSyntax created) { created = Syntax.ParseTypeName(withName); var members = equivTo.GetMembers() .OfType<PropertySymbol>() .Select( s => { var prop = Syntax.PropertyDeclaration( null, Syntax.TokenList(Syntax.ParseToken("public")), Syntax.ParseTypeName(s.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)).WithLeadingTrivia(Syntax.ParseLeadingTrivia(" ")).WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), null, Syntax.Identifier(s.Name), Syntax.AccessorList( Syntax.List( Syntax.AccessorDeclaration( SyntaxKind.GetAccessorDeclaration, null, Syntax.TokenList(), Syntax.ParseToken("get"), null, Syntax.ParseToken(";") ), Syntax.AccessorDeclaration( SyntaxKind.SetAccessorDeclaration, null, Syntax.TokenList(), Syntax.ParseToken("set"), null, Syntax.ParseToken(";") ) ) ) ); return prop; } ) .Cast<MemberDeclarationSyntax>().ToList(); var separators = new List<SyntaxToken>(); for(var i = 0; i < members.Count - 1; i++) separators.Add(Syntax.ParseToken(",")); var obj = Syntax.AnonymousObjectCreationExpression( Syntax.SeparatedList( equivTo.GetMembers() .OfType<PropertySymbol>() .Select( p => { var exp = Syntax.IdentifierName(p.Name); return Syntax.AnonymousObjectMemberDeclarator(exp); } ), separators ) ).WithLeadingTrivia(Syntax.ParseLeadingTrivia(" ")); // Build the ToString() method that anonymous types have to have var toStringRef = Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, obj, Syntax.ParseToken("."), Syntax.IdentifierName("ToString")); var toStringAccess = Syntax.InvocationExpression(toStringRef); var toStringRet = Syntax.ReturnStatement(toStringAccess); var toStringStatements = Syntax.List<StatementSyntax>(toStringRet); var toStringBody = Syntax.Block( Syntax.ParseToken("{"), toStringStatements, Syntax.ParseToken("}") ); var toString = Syntax.MethodDeclaration( null, Syntax.TokenList(Syntax.ParseToken("public").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), Syntax.ParseToken("override").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" "))), Syntax.ParseTypeName("string").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), null, Syntax.Identifier("ToString"), null, Syntax.ParameterList(), null, toStringBody ); members.Add(toString); // Adding GetHashCode override anonymous types must have var hashCodeRef = Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, obj, Syntax.ParseToken("."), Syntax.IdentifierName("GetHashCode")); var hashCodeAccess = Syntax.InvocationExpression(hashCodeRef); var hashCodeRet = Syntax.ReturnStatement(hashCodeAccess); var hashCodeStatements = Syntax.List<StatementSyntax>(hashCodeRet); var hashCodeBody = Syntax.Block( Syntax.ParseToken("{"), hashCodeStatements, Syntax.ParseToken("}") ); var hashCode = Syntax.MethodDeclaration( null, Syntax.TokenList(Syntax.ParseToken("public").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), Syntax.ParseToken("override").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" "))), Syntax.ParseTypeName("int").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), null, Syntax.Identifier("GetHashCode"), null, Syntax.ParameterList(), null, hashCodeBody ); members.Add(hashCode); // Adding Equals method anonymous types must have var equalsAs = Syntax.ParseExpression("o as " + withName); var equalsAssign = Syntax.VariableDeclaration( created.WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), Syntax.SeparatedList( Syntax.VariableDeclarator( Syntax.Identifier("other"), null, Syntax.EqualsValueClause(equalsAs) ) ) ); var equalsEqualsRef = Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, obj, Syntax.ParseToken("."), Syntax.IdentifierName("Equals")); var equalsAccess = Syntax.InvocationExpression(equalsEqualsRef, Syntax.ArgumentList(Syntax.SeparatedList(Syntax.Argument(Syntax.ParseExpression("o"))))); var equalsIf = Syntax.IfStatement( Syntax.ParseExpression("other == null"), Syntax.ReturnStatement(equalsAccess) ); var equalsEqualsExps = equivTo.GetMembers() .OfType<PropertySymbol>() .Select( p => { var n = p.Name; ExpressionSyntax ret; if (p.Type.IsReferenceType) { var strExp = "(" + n + " != null ? " + n + ".Equals(other." + n + ") : (other." + n + " != null ? other." + n + ".Equals(" + n + ") : true ))"; ret = Syntax.ParseExpression(strExp); } else { ret = Syntax.ParseExpression(n + " == other." + n); } return ret.WithLeadingTrivia(Syntax.ParseLeadingTrivia(" ")).WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")); } ).ToList(); ExpressionSyntax equalsBinary = equalsEqualsExps.First(); for (var i = 1; i < equalsEqualsExps.Count; i++) equalsBinary = Syntax.BinaryExpression(SyntaxKind.LogicalAndExpression, equalsBinary, equalsEqualsExps[i]); var equalsBinaryRet = Syntax.ReturnStatement(equalsBinary.WithLeadingTrivia(Syntax.ParseLeadingTrivia(" "))); var equalsStatements = Syntax.List( (StatementSyntax)Syntax.LocalDeclarationStatement(equalsAssign), (StatementSyntax)equalsIf, (StatementSyntax)equalsBinaryRet ); var equalsBody = Syntax.Block( Syntax.ParseToken("{"), equalsStatements, Syntax.ParseToken("}") ); var equals = Syntax.MethodDeclaration( null, Syntax.TokenList(Syntax.ParseToken("public").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), Syntax.ParseToken("override").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" "))), Syntax.ParseTypeName("bool").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), null, Syntax.Identifier("Equals"), null, Syntax.ParameterList( Syntax.SeparatedList( Syntax.Parameter( null, Syntax.TokenList(), Syntax.ParseTypeName("object").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), Syntax.Identifier("o"), null ) ) ), null, equalsBody ); members.Add(equals); var equiv = Syntax.ClassDeclaration( null, Syntax.ParseToken("internal").WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), Syntax.Identifier(withName).WithLeadingTrivia(Syntax.ParseLeadingTrivia(" ")).WithTrailingTrivia(Syntax.ParseTrailingTrivia(" ")), null, null, null, Syntax.List<MemberDeclarationSyntax>(members) ); var namespaces = tree.ChildNodes().OfType<NamespaceDeclarationSyntax>(); if (namespaces.Count() == 0 || namespaces.Count() > 1) { // HACK, better way to insert classes should be considered throw new Exception("Making some assumptions about namespaces, you can only have 1"); } var @namespace = namespaces.Single(); var updated = @namespace.WithMembers( @namespace.Members.Add(equiv) ); return tree.ReplaceNode(@namespace, updated); }
protected override void CompileType(TypeSyntax type) { var info = GetModel(type).GetSymbolInfo(type); var symbol = info.Symbol; if (symbol != null && TranslationLookup.SymbolMap.ContainsKey(symbol)) { Write(TranslationLookup.SymbolMap[symbol].Translation); } else { var predefined = type as PredefinedTypeSyntax; if (null != predefined) { if (predefined.Keyword.ToString() == "void") { Write("void"); } } else { Write("ERROR(Unsupported type : {0})", type); } } }
protected abstract void CompileVariableDeclarator(VariableDeclaratorSyntax declarator, TypeSyntax type);
protected abstract void CompileType(TypeSyntax type);