public static void Go(OutputWriter writer, ConstructorInitializerSyntax method) { writer.WriteIndent(); // var symbl = TypeProcessor.GetSymbolInfo(method); // var mysymbl = TypeProcessor.GetSymbolInfo(method.Parent); // var className = symbl.Symbol.ContainingType; if (method.ThisOrBaseKeyword.RawKind == (int) SyntaxKind.ThisKeyword) writer.Write("this"); else writer.Write("super"); // writer.Write(TypeProcessor.ConvertType(className)); writer.Write("("); bool first = true; foreach (var expression in method.ArgumentList.Arguments) { if (first) first = false; else writer.Write(", "); Core.Write(writer, expression.Expression); } writer.Write(")"); }
private ConstructorDeclarationSyntax ParseConstructorDeclaration(string typeName, SyntaxListBuilder <AnnotationSyntax> attributes, SyntaxListBuilder modifiers, TypeParameterListSyntax typeParameterList) { var name = this.ParseIdentifierToken(); Debug.Assert(name.ValueText == typeName); var saveTerm = this._termState; this._termState |= TerminatorState.IsEndOfMethodSignature; try { var paramList = this.ParseParenthesizedParameterList(allowThisKeyword: false, allowDefaults: true, allowAttributes: true, allowFieldModifiers: false); JavaThrowsListClauseSyntax throws = this.ParseJavaThrowsListClause(true); ConstructorInitializerSyntax initializer = null; if (this.CurrentToken.Kind == SyntaxKind.ColonToken) { bool isStatic = modifiers != null && modifiers.Any(SyntaxKind.StaticKeyword); initializer = this.ParseConstructorInitializer(name.ValueText, isStatic); } BlockSyntax body; SyntaxToken semicolon; this.ParseBodyOrSemicolon(out body, out semicolon); return(_syntaxFactory.ConstructorDeclaration(attributes, modifiers.ToTokenList(), typeParameterList, name, paramList, throws, initializer, body, semicolon)); } finally { this._termState = saveTerm; } }
> GetConstructorInitializerParameterLists( SemanticModel semanticModel, int position, ConstructorInitializerSyntax constructorInitializer, CancellationToken cancellationToken ) { var within = semanticModel.GetEnclosingNamedType(position, cancellationToken); if ( within != null && (within.TypeKind == TypeKind.Struct || within.TypeKind == TypeKind.Class) ) { var type = constructorInitializer.Kind() == SyntaxKind.BaseConstructorInitializer ? within.BaseType : within; if (type != null) { return type.InstanceConstructors .Where(c => c.IsAccessibleWithin(within)) .Select(c => c.Parameters); } } return null; }
public static void Go(OutputWriter writer, ConstructorInitializerSyntax method) { writer.WriteIndent(); // var symbl = TypeProcessor.GetSymbolInfo(method); // var mysymbl = TypeProcessor.GetSymbolInfo(method.Parent); // var className = symbl.Symbol.ContainingType; if (method.ThisOrBaseKeyword.RawKind == (int)SyntaxKind.ThisKeyword) { writer.Write("this"); } else { writer.Write("super"); } // writer.Write(TypeProcessor.ConvertType(className)); writer.Write("("); bool first = true; foreach (var expression in method.ArgumentList.Arguments) { if (first) { first = false; } else { writer.Write(", "); } Core.Write(writer, expression.Expression); } writer.Write(")"); }
public static void Write(this ConstructorInitializerSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context) { var symbol = (IMethodSymbol)context.SemanticModel.GetSymbolInfo(syntax).Symbol; if (syntax.Kind() == SyntaxKind.BaseConstructorInitializer) { textWriter.Write("(element % _M.DOT_LVL(typeObject.Level - 1))._C_0_"); context.SignatureWriter.WriteSignature(symbol.Parameters.Select(p => p.Type).ToArray(), textWriter); } else if (syntax.Kind() == SyntaxKind.ThisConstructorInitializer) { textWriter.Write("(element % _M.DOT_LVL(typeObject.Level))"); var signatureWriter = textWriter.CreateTextWriterAtSameIndent(); var hasGenericComponents = context.SignatureWriter.WriteSignature(symbol.Parameters.Select(p => p.Type).ToArray(), signatureWriter); if (hasGenericComponents) { textWriter.Write("['_C_0_'..("); textWriter.AppendTextWriter(signatureWriter); textWriter.Write(")]"); } else { textWriter.Write("._C_0_"); textWriter.AppendTextWriter(signatureWriter); } } syntax.ArgumentList.Write(textWriter, context); textWriter.WriteLine(";"); }
public override void VisitConstructorInitializer(ConstructorInitializerSyntax node) { var ctor = this.semanticModel.GetSymbolSafe(node, this.cancellationToken); if (ctor != null) { for (var i = 0; i < node.ArgumentList.Arguments.Count; i++) { var arg = node.ArgumentList.Arguments[i].Expression as IdentifierNameSyntax; if (this.constructor.ParameterList.Parameters.TryGetSingle(x => x.Identifier.ValueText == arg?.Identifier.ValueText, out ParameterSyntax match)) { if (this.ParameterNameMap.ContainsKey(match)) { this.ParameterNameMap[match] = null; } else { if (ctor.Parameters.Length - 1 <= i && ctor.Parameters[ctor.Parameters.Length - 1].IsParams) { this.ParameterNameMap.Add(match, null); } else { this.ParameterNameMap.Add(match, ctor.Parameters[i].Name); } } } } } base.VisitConstructorInitializer(node); }
public override void VisitConstructorInitializer(ConstructorInitializerSyntax node) { var binder = _enclosing.WithAdditionalFlags(BinderFlags.ConstructorInitializer); AddToMap(node, binder); VisitConstructorInitializerArgumentList(node, node.ArgumentList, binder); }
private static TextSpan CreateSpanForConstructorInitializer( ConstructorInitializerSyntax constructorInitializer ) => CreateSpan( constructorInitializer.ThisOrBaseKeyword, constructorInitializer.ArgumentList.CloseParenToken );
public override void VisitConstructorInitializer(ConstructorInitializerSyntax node) { if (this.method.MethodKind == MethodKind.Constructor) { var calledCtor = this.semanticModel.GetSymbolSafe(node, this.cancellationToken); if (this.IsValidCtor(calledCtor)) { var callingCtor = this.semanticModel.GetDeclaredSymbolSafe(node.Parent, this.cancellationToken) as IMethodSymbol; if (SymbolComparer.Equals(calledCtor.ContainingType, callingCtor?.ContainingType)) { this.initializers.Add(node); } else if (this.ctors.Contains(callingCtor)) { this.initializers.Add(node); } } } else { this.initializers.Add(node); } base.VisitConstructorInitializer(node); }
private bool ReplacementBreaksConstructorInitializer(ConstructorInitializerSyntax ctorInitializer, ConstructorInitializerSyntax newCtorInitializer) { var attributeSym = this.OriginalSemanticModel.GetSymbolInfo(ctorInitializer).Symbol; var newAttributeSym = this.SpeculativeSemanticModel.GetSymbolInfo(newCtorInitializer).Symbol; return(!SymbolsAreCompatible(attributeSym, newAttributeSym)); }
public static void Analyze(SyntaxNodeAnalysisContext context, ConstructorDeclarationSyntax constructor) { if (constructor.ParameterList?.Parameters.Any() == false && constructor.Body?.Statements.Any() == false) { SyntaxTokenList modifiers = constructor.Modifiers; if (modifiers.Contains(SyntaxKind.PublicKeyword) && !modifiers.Contains(SyntaxKind.StaticKeyword)) { ConstructorInitializerSyntax initializer = constructor.Initializer; if (initializer == null || initializer.ArgumentList?.Arguments.Any() == false) { if (IsSingleInstanceConstructor(constructor) && constructor .DescendantTrivia(constructor.Span) .All(f => f.IsWhitespaceOrEndOfLineTrivia())) { context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantConstructor, constructor); } } } } }
private bool ReplacementBreaksConstructorInitializer(ConstructorInitializerSyntax ctorInitializer, ConstructorInitializerSyntax newCtorInitializer) { var originalSymbol = this.OriginalSemanticModel.GetSymbolInfo(ctorInitializer, CancellationToken).Symbol; var newSymbol = this.SpeculativeSemanticModel.GetSymbolInfo(newCtorInitializer, CancellationToken).Symbol; return(!SymbolsAreCompatible(originalSymbol, newSymbol)); }
public static Doc PrintWithConditionalSpace( ConstructorInitializerSyntax node, string groupId ) { return(Print(node, groupId)); }
private bool TryGetConstructorInitializer( SyntaxNode root, int position, ISyntaxFactsService syntaxFacts, SignatureHelpTriggerReason triggerReason, CancellationToken cancellationToken, out ConstructorInitializerSyntax expression ) { if ( !CommonSignatureHelpUtilities.TryGetSyntax( root, position, syntaxFacts, triggerReason, IsTriggerToken, IsArgumentListToken, cancellationToken, out expression ) ) { return(false); } return(expression.ArgumentList != null); }
public static ITypeSymbol GetTypeSymbol( this SemanticModel semanticModel, ConstructorInitializerSyntax constructorInitializer, CancellationToken cancellationToken = default(CancellationToken)) { return(Microsoft.CodeAnalysis.CSharp.CSharpExtensions .GetTypeInfo(semanticModel, constructorInitializer, cancellationToken) .Type); }
private static bool IsArgumentListToken( ConstructorInitializerSyntax expression, SyntaxToken token ) { return(expression.ArgumentList != null && expression.ArgumentList.Span.Contains(token.SpanStart) && token != expression.ArgumentList.CloseParenToken); }
private bool TryGetConstructorInitializer(SyntaxNode root, int position, ISyntaxFactsService syntaxFacts, SignatureHelpTriggerReason triggerReason, CancellationToken cancellationToken, out ConstructorInitializerSyntax expression) { if (!CommonSignatureHelpUtilities.TryGetSyntax(root, position, syntaxFacts, triggerReason, IsTriggerToken, IsArgumentListToken, cancellationToken, out expression)) { return false; } return expression.ArgumentList != null; }
// TODO 0 where is this used? I changed it and nothing broke public static Doc Print(ConstructorInitializerSyntax node) { return(Doc.Indent( Doc.HardLine, Token.Print(node.ColonToken, " "), Token.Print(node.ThisOrBaseKeyword), ArgumentList.Print(node.ArgumentList) )); }
internal override bool TryGetSpeculativeSemanticModelCore( SyntaxTreeSemanticModel parentModel, int position, ConstructorInitializerSyntax constructorInitializer, out SemanticModel speculativeModel ) { throw ExceptionUtilities.Unreachable; }
public static bool ContainsInArgument(this ConstructorInitializerSyntax initializer, TextSpan textSpan) { if (initializer == null) { return(false); } return(initializer.ArgumentList.Arguments.Any(a => a.Span.Contains(textSpan))); }
public static ITypeSymbol GetTypeSymbol( this SemanticModel semanticModel, ConstructorInitializerSyntax constructorInitializer, CancellationToken cancellationToken = default(CancellationToken)) { return(semanticModel .GetTypeInfo(constructorInitializer, cancellationToken) .Type); }
public new void AddChildren() { base.AddChildren(); Kind = Node.Kind(); _identifier = ((ConstructorDeclarationSyntax)Node).Identifier; _identifierIsChanged = false; _initializer = ((ConstructorDeclarationSyntax)Node).Initializer; _initializerIsChanged = false; }
private static void AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context) { var constructor = (ConstructorDeclarationSyntax)context.Node; if (constructor.ContainsDiagnostics) { return; } if (constructor.ParameterList?.Parameters.Any() != false) { return; } if (constructor.Body?.Statements.Any() != false) { return; } SyntaxTokenList modifiers = constructor.Modifiers; if (!modifiers.Contains(SyntaxKind.PublicKeyword)) { return; } if (modifiers.Contains(SyntaxKind.StaticKeyword)) { return; } ConstructorInitializerSyntax initializer = constructor.Initializer; if (initializer != null && initializer.ArgumentList?.Arguments.Any() != false) { return; } if (!IsSingleInstanceConstructor(constructor)) { return; } if (constructor.HasDocumentationComment()) { return; } if (!constructor.DescendantTrivia(constructor.Span).All(f => f.IsWhitespaceOrEndOfLineTrivia())) { return; } DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.RemoveRedundantConstructor, constructor); }
private static bool IsInitializerEmptyOrRedundant(ConstructorInitializerSyntax initializer) { if (initializer == null) { return(true); } return(initializer.ArgumentList.Arguments.Count == 0 && initializer.ThisOrBaseKeyword.IsKind(SyntaxKind.BaseKeyword)); }
private Doc PrintConstructorInitializerSyntax( ConstructorInitializerSyntax node) { return(Indent( HardLine, this.PrintSyntaxToken(node.ColonToken, " "), this.PrintSyntaxToken(node.ThisOrBaseKeyword), this.PrintArgumentListSyntax(node.ArgumentList) )); }
public static ConstructorDeclarationSyntax ConstructorDeclaration( IEnumerable <SyntaxKind> modifiers, string className, IEnumerable <ParameterSyntax> parameters = null, IEnumerable <StatementSyntax> statements = null, ConstructorInitializerSyntax constructorInitializer = null) { return(Syntax.ConstructorDeclaration(className) .WithModifiers(TokenList(modifiers)) .WithParameterList(Syntax.ParameterList(parameters.ToSeparatedList())) .WithBody(Syntax.Block(statements.ToSyntaxList())) .WithInitializer(constructorInitializer)); }
private static ArgumentSyntax CriteriaArg(ConstructorInitializerSyntax initializer, IMethodSymbol ctor) { if (ctor.Parameters[0].Type == KnownSymbol.FuncOfT && ctor.Parameters[1].Type == KnownSymbol.IObservableOfT) { return(initializer.ArgumentList.Arguments[0]); } return(initializer.ArgumentList.Arguments[1]); }
private Block BuildConstructorInitializer(ConstructorInitializerSyntax initializer, Block currentBlock) { currentBlock.ReversedInstructions.Add(initializer); var arguments = initializer.ArgumentList == null ? Enumerable.Empty <ExpressionSyntax>() : initializer.ArgumentList.Arguments.Select(a => a.Expression); return(BuildExpressions(arguments, currentBlock)); }
internal override bool TryGetSpeculativeSemanticModelCore( SyntaxTreeSemanticModel parentModel, int position, ConstructorInitializerSyntax constructorInitializer, out SemanticModel speculativeModel ) { speculativeModel = null; return(false); }
private MethodDeclarationSyntax ParseMethodDeclaration( SyntaxListBuilder <AnnotationSyntax> attributes, SyntaxListBuilder modifiers, TypeSyntax type, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, bool isDtor) { // Parse the name (it could be qualified) var saveTerm = this._termState; this._termState |= TerminatorState.IsEndOfMethodSignature; var paramList = this.ParseParenthesizedParameterList(allowThisKeyword: true, allowDefaults: true, allowAttributes: true, allowFieldModifiers: true); JavaThrowsListClauseSyntax throws = this.ParseJavaThrowsListClause(true); if (this.CurrentToken.Kind == SyntaxKind.ColonToken) { // Use else if, rather than if, because if we see both a constructor initializer and a constraint clause, we're too lost to recover. var colonToken = this.CurrentToken; // Set isStatic to false because pretending we're in a static constructor will just result in more errors. ConstructorInitializerSyntax initializer = this.ParseConstructorInitializer(identifier.ValueText, isStatic: false); initializer = this.AddErrorToFirstToken(initializer, ErrorCode.ERR_UnexpectedCharacter, colonToken.Text); //CONSIDER: better error code? paramList = AddTrailingSkippedSyntax(paramList, initializer); // CONSIDER: Parsing an invalid constructor initializer could, conceivably, get us way // off track. If this becomes a problem, an alternative approach would be to generalize // EatTokenWithPrejudice in such a way that we can just skip everything until we recognize // our context again (perhaps an open brace). } this._termState = saveTerm; BlockSyntax body; SyntaxToken semicolon; this.ParseBodyOrSemicolon(out body, out semicolon); return (_syntaxFactory.MethodDeclaration(isDtor ? SyntaxKind.DestructorDeclaration : SyntaxKind.MethodDeclaration, attributes, modifiers.ToTokenList(), typeParameterList, type, identifier, paramList, throws, body, semicolon)); }
public override void VisitConstructorInitializer(ConstructorInitializerSyntax node) { if (this.visited.Add(node) && this.semanticModel.GetSymbolSafe(node, this.cancellationToken) is IMethodSymbol ctor && ctor.TrySingleDeclaration(this.cancellationToken, out ConstructorDeclarationSyntax declaration)) { this.Visit(declaration); } base.VisitConstructorInitializer(node); }
public override void VisitConstructorInitializer(ConstructorInitializerSyntax node) { var ctor = this.semanticModel.GetSymbolSafe(node, this.cancellationToken); if (ctor.TryGetSingleDeclaration(this.cancellationToken, out ConstructorDeclarationSyntax declaration)) { this.Visit(declaration); } base.VisitConstructorInitializer(node); }
public static ConstructorDeclarationSyntax ConstructorDeclaration( SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, ParameterListSyntax parameterList, ConstructorInitializerSyntax initializer, ArrowExpressionClauseSyntax expressionBody) => ConstructorDeclaration( attributeLists, modifiers, identifier, parameterList, initializer, default(BlockSyntax), expressionBody, default(SyntaxToken));
public ConstructorDeclarationSyntax Update( SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, ParameterListSyntax parameterList, ConstructorInitializerSyntax initializer, BlockSyntax body, SyntaxToken semicolonToken) => Update( attributeLists, modifiers, identifier, parameterList, initializer, body, default(ArrowExpressionClauseSyntax), semicolonToken);
private async Task<Document> PropagateConstructorParams( Document document, ConstructorInitializerSyntax constructorInitializerNode, ImmutableArray<IParameterSymbol> baseConstrParams, CancellationToken cancellationToken) { var semanticModel = await document.GetSemanticModelAsync(); var classDecl = constructorInitializerNode.FirstAncestorOrSelf<ClassDeclarationSyntax>(); var classSymbol = semanticModel.GetDeclaredSymbol(classDecl); var constructorDecl = constructorInitializerNode.FirstAncestorOrSelf<ConstructorDeclarationSyntax>(); var constructorSymbol = classSymbol.Constructors .Where(p => p.Parameters.Count() == constructorDecl.ParameterList.Parameters.Count) .FirstOrDefault(); var invArgList = constructorInitializerNode.ArgumentList; var declParamList = constructorDecl.ParameterList; int idx = -1; foreach(var baseP in baseConstrParams) { idx++; if (constructorSymbol.Parameters.Any(p => p.Type.Name == baseP.Type.Name)) continue; declParamList = declParamList.AddParameters( SyntaxFactory.Parameter( SyntaxFactory.Identifier(baseP.Name)) .WithType( SyntaxFactory.IdentifierName(baseP.Type.Name))); invArgList = SyntaxFactory.ArgumentList(invArgList.Arguments.Insert(idx, SyntaxFactory.Argument(SyntaxFactory.IdentifierName(baseP.Name)))); } var root = await document.GetSyntaxRootAsync(); var newConstructor = constructorDecl.WithParameterList(declParamList) .WithInitializer(constructorInitializerNode.WithArgumentList(invArgList)); root = root.ReplaceNode(constructorDecl, newConstructor); return document.WithSyntaxRoot(root); }
public ConstructorInitializerTranslation(ConstructorInitializerSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { ThisOrBaseKeyword = syntax.ThisOrBaseKeyword.Get(this); ArgumentList = syntax.ArgumentList.Get<ArgumentListTranslation>(this); }
/// <summary> /// Gets a list of method or indexed property symbols for a syntax node. /// </summary> /// <param name="initializer">The syntax node to get semantic information for.</param> /// <param name="cancellationToken">The cancellation token.</param> public ImmutableArray<ISymbol> GetMemberGroup(ConstructorInitializerSyntax initializer, CancellationToken cancellationToken = default(CancellationToken)) { CheckSyntaxNode(initializer); return CanGetSemanticInfo(initializer) ? StaticCast<ISymbol>.From(this.GetMemberGroupWorker(initializer, SymbolInfoOptions.DefaultOptions, cancellationToken)) : ImmutableArray<ISymbol>.Empty; }
/// <summary> /// Gets type information about a constructor initializer. /// </summary> /// <param name="constructorInitializer">The syntax node to get semantic information for.</param> /// <param name="cancellationToken">The cancellation token.</param> public TypeInfo GetTypeInfo(ConstructorInitializerSyntax constructorInitializer, CancellationToken cancellationToken = default(CancellationToken)) { CheckSyntaxNode(constructorInitializer); return CanGetSemanticInfo(constructorInitializer) ? GetTypeInfoWorker(constructorInitializer, cancellationToken) : CSharpTypeInfo.None; }
/// <summary> /// Bind the constructor initializer in the context of the specified location and get semantic information /// such as type, symbols and diagnostics. This method is used to get semantic information about a constructor /// initializer that did not actually appear in the source code. /// /// NOTE: This will only work in locations where there is already a constructor initializer. /// </summary> /// <param name="position">A character position used to identify a declaration scope and accessibility. This /// character position must be within the FullSpan of the Root syntax node in this SemanticModel. /// Furthermore, it must be within the span of an existing constructor initializer. /// </param> /// <param name="constructorInitializer">A syntax node that represents a parsed constructor initializer. This syntax node /// need not and typically does not appear in the source code referred to SemanticModel instance.</param> /// <returns>The semantic information for the topmost node of the constructor initializer.</returns> public SymbolInfo GetSpeculativeSymbolInfo(int position, ConstructorInitializerSyntax constructorInitializer) { Debug.Assert(CanGetSemanticInfo(constructorInitializer, isSpeculative: true)); position = CheckAndAdjustPosition(position); if (constructorInitializer == null) { throw new ArgumentNullException(nameof(constructorInitializer)); } // NOTE: since we're going to be depending on a MemberModel to do the binding for us, // we need to find a constructor initializer in the tree of this semantic model. // NOTE: This approach will not allow speculative binding of a constructor initializer // on a constructor that didn't formerly have one. // TODO: Should we support positions that are not in existing constructor initializers? // If so, we will need to build up the context that would otherwise be built up by // InitializerMemberModel. var existingConstructorInitializer = this.Root.FindToken(position).Parent.AncestorsAndSelf().OfType<ConstructorInitializerSyntax>().FirstOrDefault(); if (existingConstructorInitializer == null) { return SymbolInfo.None; } MemberSemanticModel memberModel = GetMemberModel(existingConstructorInitializer); if (memberModel == null) { return SymbolInfo.None; } var binder = this.GetEnclosingBinder(position); if (binder != null) { var diagnostics = DiagnosticBag.GetInstance(); if (constructorInitializer.ArgumentList != null) { binder = new ExecutableCodeBinder(constructorInitializer.ArgumentList, binder.ContainingMemberOrLambda, binder); } var bnode = memberModel.Bind(binder, constructorInitializer, diagnostics); var binfo = memberModel.GetSymbolInfoForNode(SymbolInfoOptions.DefaultOptions, bnode, bnode, boundNodeForSyntacticParent: null, binderOpt: binder); diagnostics.Free(); return binfo; } else { return SymbolInfo.None; } }
private static bool IsInitializerEmptyOrRedundant(ConstructorInitializerSyntax initializer) { if (initializer == null) { return true; } return initializer.ArgumentList != null && !initializer.ArgumentList.Arguments.Any() && initializer.ThisOrBaseKeyword.IsKind(SyntaxKind.BaseKeyword); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitConstructorInitializer(ConstructorInitializerSyntax node) { this.OnNodeVisited(node); if (!this.traverseRootOnly) base.VisitConstructorInitializer(node); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitConstructorInitializer(ConstructorInitializerSyntax node) { this.OnNodeVisited(node, this.type.IsInstanceOfType(node)); base.VisitConstructorInitializer(node); }
private IEnumerable<ITypeSymbol> InferTypeInConstructorInitializer(ConstructorInitializerSyntax initializer, int index, ArgumentSyntax argument = null) { var info = this.semanticModel.GetSymbolInfo(initializer, cancellationToken); var methods = info.GetBestOrAllSymbols().OfType<IMethodSymbol>(); return InferTypeInArgument(index, methods, argument); }
/// <summary> /// the constructor initializer will be extended /// so that it will accept the mixin as parameter. /// See rule 3 from above /// </summary> /// <param name="oldConstructorInitializer"></param> /// <returns></returns> public ConstructorInitializerSyntax ExtendConstructorInitialization( ConstructorInitializerSyntax oldConstructorInitializer) { // don't do anything if initializer points to base if (oldConstructorInitializer.IsKind(SyntaxKind.BaseConstructorInitializer)) return oldConstructorInitializer; var parameterName = _mixin.Name.ConvertFieldNameToParameterName(); // arguments that are already used in the constructor initializer var arguments = oldConstructorInitializer .ArgumentList .Arguments .ToArray(); // the initializer can have default parameters that are not visible in the syntax tree, // therefore we have to use some additional semantic information here var initalizerSymbol = _semantic.GetSymbolInfo(oldConstructorInitializer).Symbol as IMethodSymbol; if (initalizerSymbol != null) { var constructorArguments = new List<ConstructorArgument>(); // special case: the initializer does not have any parameters yet // so we simply add one if(initalizerSymbol.Parameters.Length == 0) { return oldConstructorInitializer .AddArgumentListArguments( Argument(IdentifierName(parameterName))); } // otherwise, try to map the arguments from the initializer // with the parameters of the constructor and add the new argument // at the correct position for (var i=0; i < initalizerSymbol.Parameters.Length;i++) { var parameter = initalizerSymbol.Parameters[i]; // this constructor argument will hold our new mixin if (parameter.Name == parameterName) { constructorArguments.Add( new ConstructorArgument( parameter.Name, expression: IdentifierName(parameterName), isMixinParameter: true)); } else { // we either have an argument with an explicit name // or we have an argument at the same position // or we can ommit this parameter ArgumentSyntax argument = arguments .Where(x => x.NameColon != null) .FirstOrDefault(x => x.NameColon.Name.GetText().ToString() == parameter.Name); // argument identified by name or by position if (argument == null) if (arguments.Length > i) argument = arguments[i]; if (argument != null) constructorArguments.Add(new ConstructorArgument(parameter.Name,expression: argument.Expression)); else // no argument found => argument was omitted constructorArguments.Add(new ConstructorArgument(parameter.Name,canBeOmitted:true)); } } // now we have to check again if we must use explicit naming // this is the case if a previous parameter is omitted but // the current one is not ConstructorArgument previous = null; foreach (var constructorArgument in constructorArguments) { constructorArgument.NeedsExplicitNaming = previous != null && previous.CanBeOmitted && !constructorArgument.CanBeOmitted; previous = constructorArgument; } // create the new initializer by recreating the complete argument list var newConstructorInitializer = oldConstructorInitializer .WithArgumentList(ArgumentList() .AddArguments(constructorArguments .Where(x => x.Expression != null) .Select(x => x.NeedsExplicitNaming ? Argument(NameColon(x.Name), default(SyntaxToken),x.Expression) : Argument(x.Expression)) .ToArray())); return newConstructorInitializer; } return oldConstructorInitializer; }
private static bool IsArgumentListToken(ConstructorInitializerSyntax expression, SyntaxToken token) { return expression.ArgumentList != null && expression.ArgumentList.Span.Contains(token.SpanStart) && token != expression.ArgumentList.CloseParenToken; }
public void VisitConstructorInitializer(ConstructorInitializerSyntax node) { if (node == null) throw new ArgumentNullException("node"); node.Validate(); if (_writer.Configuration.LineBreaksAndWrapping.Other.PlaceConstructorInitializerOnSameLine) { _writer.WriteSpace(); } else { _writer.WriteLine(); _writer.PushIndent(); _writer.WriteIndent(); } _writer.WriteSyntax(Syntax.Colon); _writer.WriteSpace(); _writer.WriteKeyword(node.Kind == ThisOrBase.This ? PrinterKeyword.This : PrinterKeyword.Base); node.ArgumentList.Accept(this); if (!_writer.Configuration.LineBreaksAndWrapping.Other.PlaceConstructorInitializerOnSameLine) _writer.PopIndent(); }
/// <summary> /// Creates a SemanticModel for a constructor initializer (": this(...)" or ": base(...)"). /// </summary> internal static InitializerSemanticModel Create(CSharpCompilation compilation, ConstructorInitializerSyntax syntax, MethodSymbol methodSymbol, Binder rootBinder) { return new InitializerSemanticModel(compilation, syntax, methodSymbol, rootBinder); }
public override void VisitConstructorInitializer(ConstructorInitializerSyntax node) { base.VisitConstructorInitializer(node); var method = context.SemanticModel.GetSymbolInfo(node).Symbol as IMethodSymbol; if (method != null) { CheckArguments(node.ArgumentList.Arguments, method.Parameters); } }
private static void RegisterActionForBaseCall(CodeFixContext context, SyntaxNode root, ConstructorInitializerSyntax initializer) { var constructor = initializer.Parent as ConstructorDeclarationSyntax; if (constructor == null) { return; } context.RegisterCodeFix( CodeAction.Create( TitleRemoveBaseCall, c => { var newRoot = RemoveInitializer(root, constructor); return Task.FromResult(context.Document.WithSyntaxRoot(newRoot)); }, TitleRemoveBaseCall), context.Diagnostics); }
internal sealed override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, ConstructorInitializerSyntax constructorInitializer, out SemanticModel speculativeModel) { position = CheckAndAdjustPosition(position); var model = this.GetMemberModel(position); if (model != null) { return model.TryGetSpeculativeSemanticModelCore(parentModel, position, constructorInitializer, out speculativeModel); } speculativeModel = null; return false; }
/// <summary> /// Returns what symbol(s), if any, the given constructor initializer syntax bound to in the program. /// </summary> /// <param name="constructorInitializer">The syntax node to get semantic information for.</param> /// <param name="cancellationToken">The cancellation token.</param> public SymbolInfo GetSymbolInfo(ConstructorInitializerSyntax constructorInitializer, CancellationToken cancellationToken = default(CancellationToken)) { CheckSyntaxNode(constructorInitializer); return CanGetSemanticInfo(constructorInitializer) ? GetSymbolInfoWorker(constructorInitializer, SymbolInfoOptions.DefaultOptions, cancellationToken) : SymbolInfo.None; }
/// <summary> /// Get a SemanticModel object that is associated with a constructor initializer that did not appear in /// this source code. This can be used to get detailed semantic information about sub-parts /// of a constructor initializer that did not appear in source code. /// /// NOTE: This will only work in locations where there is already a constructor initializer. /// </summary> /// <param name="position">A character position used to identify a declaration scope and accessibility. This /// character position must be within the FullSpan of the Root syntax node in this SemanticModel. /// Furthermore, it must be within the span of an existing constructor initializer. /// </param> /// <param name="constructorInitializer">A syntax node that represents a parsed constructor initializer. /// This node should not be present in the syntax tree associated with this object.</param> /// <param name="speculativeModel">A SemanticModel object that can be used to inquire about the semantic /// information associated with syntax nodes within <paramref name="constructorInitializer"/>.</param> /// <returns>Flag indicating whether a speculative semantic model was created.</returns> /// <exception cref="ArgumentException">Throws this exception if the <paramref name="constructorInitializer"/> node is contained any SyntaxTree in the current Compilation.</exception> /// <exception cref="ArgumentNullException">Throws this exception if <paramref name="constructorInitializer"/> is null.</exception> /// <exception cref="InvalidOperationException">Throws this exception if this model is a speculative semantic model, i.e. <see cref="SemanticModel.IsSpeculativeSemanticModel"/> is true. /// Chaining of speculative semantic model is not supported.</exception> public bool TryGetSpeculativeSemanticModel(int position, ConstructorInitializerSyntax constructorInitializer, out SemanticModel speculativeModel) { CheckModelAndSyntaxNodeToSpeculate(constructorInitializer); return TryGetSpeculativeSemanticModelCore((SyntaxTreeSemanticModel)this, position, constructorInitializer, out speculativeModel); }
private static bool IsInitializerRedundant(ConstructorInitializerSyntax initializer) { return initializer.IsKind(SyntaxKind.BaseConstructorInitializer) && initializer.ArgumentList != null && !initializer.ArgumentList.Arguments.Any(); }
internal abstract bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, ConstructorInitializerSyntax constructorInitializer, out SemanticModel speculativeModel);
internal override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, ConstructorInitializerSyntax constructorInitializer, out SemanticModel speculativeModel) { throw ExceptionUtilities.Unreachable; }
internal override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, ConstructorInitializerSyntax constructorInitializer, out SemanticModel speculativeModel) { speculativeModel = null; return false; }
public override SyntaxNode VisitConstructorInitializer(ConstructorInitializerSyntax node) { node = (ConstructorInitializerSyntax)base.VisitConstructorInitializer(node); node = _injectMixinIntoConstructor.ExtendConstructorInitialization(node); return node; }