private IConstructorDeclaration CreateConstructor(IClassDeclaration classDeclaration, IIdentifier fieldIdentifier, ITypeName typeName) { IConstructLanguage language = classDeclaration.Language; IParameter parameter = language.Parameter(typeName); NamingPolicy parameterNamingPolicy = parameter.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings); string parameterName = parameterNamingPolicy.ChangeNameAccordingToPolicy(classDeclaration.Identifier.Name, classDeclaration.SolutionModel); parameter.Identifier = language.Identifier(parameterName); Modifiers constructorModifiers = Modifiers.Public; Modifiers visibility = classDeclaration.Modifiers.Modifiers.GetVisibility(); if (visibility == Modifiers.None || visibility.IsInternal()) { constructorModifiers = Modifiers.Internal; } IConstructorDeclaration constructor = language.Constructor(language.None <IDocComment>(), language.None <IAttributes>(), language.Modifiers(constructorModifiers), language.Parameters(parameter), language.None <IConstructorInitializer>(), language.Block( language.AssignmentStatement( language.MemberAccess(language.This(), fieldIdentifier), language.VariableAccess(parameter.Identifier)))); return(constructor); }
protected internal NewFormula(IConstructorDeclaration constructor, ReadOnlyCollection<Formula> arguments, ReadOnlyCollection<IMemberDeclaration> members) : base(NodeType.New, constructor.DeclaringType) { Constructor = constructor; Arguments = arguments; Members = members; }
private static FixedList <ParameterIL> BuildConstructorParameters(IConstructorDeclaration constructorDeclaration) { var selfParameterSymbol = constructorDeclaration.ImplicitSelfParameter.Symbol; var selfParameter = new SelfParameterIL(selfParameterSymbol); return(selfParameter.Yield().Concat(constructorDeclaration.Parameters.Select(BuildParameter)).ToFixedList()); }
public static IMethodName GetName([NotNull] this IConstructorDeclaration constructorDeclaration) { // TODO testing! var declaredElement = constructorDeclaration.DeclaredElement; Asserts.NotNull(declaredElement, "no declared element in declaration"); return(declaredElement.GetName <IMethodName>()); }
private IEnumerable <IInvocationExpression> GetInvocationExpressions(IConstructorDeclaration constructorDeclaration) { var statementExpressions = constructorDeclaration.Body.Children <IExpressionStatement>().Select(x => x.Expression); var invocationExpressions = statementExpressions.OfType <IInvocationExpression>() .SelectMany(z => z.DescendantsAndSelf(x => x.InvokedExpression.FirstChild as IInvocationExpression).Reverse()); return(invocationExpressions); }
internal InternalConstructorVisibilityHighlighting( [NotNull] string message, [NotNull] ITokenNode modifierTokenNode, [NotNull] IConstructorDeclaration constructorDeclaration, AccessRights visibility) : base(message) { this.modifierTokenNode = modifierTokenNode; ConstructorDeclaration = constructorDeclaration; Visibility = visibility; }
private IClassDeclaration CreateViewModel(IClassDeclaration classDeclaration) { ITypeName typeName = classDeclaration.Language.TypeName(classDeclaration.Type()); IFieldDeclaration fieldDeclaration = CreateFieldToHoldWrappedClass(classDeclaration.Language, typeName, classDeclaration); IConstructorDeclaration viewModelConstructor = CreateConstructor(classDeclaration, fieldDeclaration.Identifier, typeName); IClassDeclaration viewModel = CreateInitialViewModel(classDeclaration, fieldDeclaration, viewModelConstructor); return(viewModel); }
/// <summary> /// The execute transaction inner. /// </summary> /// <param name="solution"> /// The solution. /// </param> /// <param name="textControl"> /// The text control. /// </param> public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl) { ITreeNode element = Utils.GetElementAtCaret(solution, textControl); if (element != null) { IConstructorDeclaration constructorDeclaration = element.GetContainingNode <IConstructorDeclaration>(true); if (constructorDeclaration != null) { new DocumentationRules().EnsureConstructorSummaryDocBeginsWithStandardText(constructorDeclaration); } } }
/// <summary>Inspects the control graf.</summary> /// <param name="constructor">The constructor.</param> /// <returns>Returns the control graf.</returns> public CodeAnnotationAttribute InspectControlGraf([NotNull] IConstructorDeclaration constructor) { if (constructor == null) { throw new ArgumentNullException("constructor"); } var function = constructor; if (!function.DeclaredElement.ReturnType.IsReferenceType()) { return(CodeAnnotationAttribute.Undefined); } return(CodeAnnotationAttribute.NotNull); }
public void AddAssignmentToBody(IConstructorDeclaration constructorDeclaration, IStatement anchorStatement, bool insertBefore, IParameter parameter, ITypeMember member) { var constructorDeclaration1 = constructorDeclaration; var instance = CSharpElementFactory.GetInstance(constructorDeclaration1); if (constructorDeclaration1.Body == null) constructorDeclaration1.SetBody(instance.CreateEmptyBlock()); var shortName1 = parameter.ShortName; var shortName2 = member.ShortName; var statement = instance.CreateStatement("$0 = $1;", (object) shortName2, (object) shortName1); CodeStyleUtil.ApplyRecursive<ThisQualifierStyleSuggestion>(insertBefore ? constructorDeclaration1.Body.AddStatementBefore(statement, (ICSharpStatement) anchorStatement) : constructorDeclaration1.Body.AddStatementAfter(statement, (ICSharpStatement) anchorStatement)); }
/// <summary>Inspects the specified method.</summary> /// <param name="constructor">The method.</param> public void Inspect([NotNull] IConstructorDeclaration constructor) { this.CodeAnnotation = new CodeAnnotation(constructor); if (!this.CodeAnnotation.IsValid) { return; } var body = constructor.Body; if (body == null) { return; } this.TypeMember = constructor; this.Body = body; this.AppliedReturn = CodeAnnotationAttribute.Undefined; this.ExpectedReturn = CodeAnnotationAttribute.Undefined; this.BuildParameters(constructor, false); this.BuildAssertions(body); }
/// <summary> /// Indicates whether the type of the constructor passed in is a struct. /// </summary> /// <param name="constructorDeclaration"> /// The constructor of the type to check. /// </param> /// <returns> /// True if containing type is a struct. /// </returns> public static bool IsContainingTypeAStruct(IConstructorDeclaration constructorDeclaration) { ICSharpTypeDeclaration typeDeclaration = constructorDeclaration.GetContainingTypeDeclaration(); return typeDeclaration is IStructDeclaration; }
private void ProcessFunctionDeclaration(IConstructorDeclaration constructorDeclaration) { var constructorParams = constructorDeclaration.ParameterDeclarations; var interfaceCount = constructorParams.Count(regularParameterDeclaration => regularParameterDeclaration.DeclaredElement.Type.IsInterfaceType()); if (interfaceCount > _maxParams) { string message = Stringtable.TooManyArgumentsWarning; var warning = new InjectionHappyDetectorWarning(message); _highlights.Add(new HighlightingInfo(constructorDeclaration.GetNameDocumentRange(), warning)); } }
public override void VisitConstructorDeclaration(IConstructorDeclaration constructorDeclaration, IHighlightingConsumer context) { tooManyDependenciesCheck.ExecuteIfEnabled(constructorDeclaration, context); }
/// <summary> /// Creates a new summary string for this constructor. /// </summary> /// <param name="constructorDeclaration"> /// The constructor to produce the summary for. /// </param> /// <returns> /// A string of the constructor summary text. /// </returns> public static string CreateSummaryForConstructorDeclaration(IConstructorDeclaration constructorDeclaration) { DeclarationHeader declarationHeader = new DeclarationHeader(constructorDeclaration); if (declarationHeader.IsInherited) { return declarationHeader.XmlNode.InnerXml; } IContextBoundSettingsStore settingsStore = PsiSourceFileExtensions.GetSettingsStore(null, constructorDeclaration.GetSolution()); if (!settingsStore.GetValue((StyleCopOptionsSettingsKey key) => key.InsertTextIntoDocumentation)) { return string.Empty; } bool parentIsStruct = IsContainingTypeAStruct(constructorDeclaration); string structOrClass = parentIsStruct ? "struct" : "class"; string xmlWeShouldInsert; if (constructorDeclaration.IsStatic) { xmlWeShouldInsert = string.Format(CultureInfo.InvariantCulture, HeaderSummaryForStaticConstructorXml, constructorDeclaration.DeclaredName, structOrClass); } else if (constructorDeclaration.GetAccessRights() == AccessRights.PRIVATE && constructorDeclaration.ParameterDeclarations.Count == 0) { xmlWeShouldInsert = string.Format( CultureInfo.InvariantCulture, HeaderSummaryForPrivateInstanceConstructorXml, constructorDeclaration.DeclaredName, structOrClass); } else { string constructorDescriptionText = CreateConstructorDescriptionText(constructorDeclaration, true); xmlWeShouldInsert = string.Format(CultureInfo.InvariantCulture, HeaderSummaryForInstanceConstructorXml, constructorDescriptionText, structOrClass); } return xmlWeShouldInsert; }
private static MethodRef CreateRef(IConstructorDeclaration cd) { return(MethodRef.CreateConstructorReference(cd.GetName(), cd.DeclaredElement, cd)); }
private static IParameterDeclaration AddContextParameter(IConstructorDeclaration constructorDeclaration, IDeclaration contextDeclaration) { var type = SerializationUtilities.StreamingContextTypeName.CreateTypeInContextOf(contextDeclaration); return(constructorDeclaration.AddParameterDeclarationBefore(ParameterKind.VALUE, type, "context", null)); }
public override void VisitConstructorDeclaration(IConstructorDeclaration decl, SST context) { _cancellationToken.ThrowIfCancellationRequested(); var nameGen = new UniqueVariableNameGenerator(); var exprVisit = new ExpressionVisitor(nameGen, _marker); if (decl.DeclaredElement != null) { var methodName = decl.DeclaredElement.GetName <IMethodName>(); var sstDecl = new MethodDeclaration { Name = methodName, IsEntryPoint = _entryPoints.Contains(methodName) }; context.Methods.Add(sstDecl); if (decl == _marker.AffectedNode) { sstDecl.Body.Add(new ExpressionStatement { Expression = new CompletionExpression() }); } if (decl.Initializer != null) { var name = Names.UnknownMethod; var substitution = decl.DeclaredElement.IdSubstitution; var resolvedRef = decl.Initializer.Reference.Resolve(); if (resolvedRef.DeclaredElement != null) { name = resolvedRef.DeclaredElement.GetName <IMethodName>(substitution); } var args = Lists.NewList <ISimpleExpression>(); foreach (var p in decl.Initializer.Arguments) { var expr = exprVisit.ToSimpleExpression(p.Value, sstDecl.Body); args.Add(expr); } var varId = new VariableReference().Identifier; // default value if (decl.Initializer.Instance != null) { var tokenType = decl.Initializer.Instance.GetTokenType(); var isThis = CSharpTokenType.THIS_KEYWORD == tokenType; var isBase = CSharpTokenType.BASE_KEYWORD == tokenType; varId = isThis ? "this" : isBase ? "base" : varId; } sstDecl.Body.Add( new ExpressionStatement { Expression = new InvocationExpression { Reference = new VariableReference { Identifier = varId }, MethodName = name, Parameters = args } }); } if (!decl.IsAbstract) { var bodyVisitor = new BodyVisitor(nameGen, _marker); Execute.AndSupressExceptions( delegate { decl.Accept(bodyVisitor, sstDecl.Body); }); } } }
private IClassDeclaration CreateInitialViewModel(IClassDeclaration classDeclaration, IFieldDeclaration fieldDeclaration, IConstructorDeclaration viewModelConstructor) { IConstructLanguage language = classDeclaration.Language; IClassDeclaration viewModel = language.Class( language.Modifiers(Modifiers.Public), language.None<IClassTypeParameters>(), language.None<ITypeName>(), new List<ITypeName>(), new List<IDeclaration>() { fieldDeclaration, viewModelConstructor }); NamingPolicy classesPolicy = viewModel.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings); string viewModelName = classesPolicy.MakeTypeNameUniqueInNamespace(classDeclaration, classDeclaration.Identifier.Name + "ViewModel"); viewModel.Identifier = language.Identifier(viewModelName); return viewModel; }
private void ProcessFunctionDeclaration(IConstructorDeclaration constructorDeclaration) { var constructorParams = constructorDeclaration.ParameterDeclarations; var interfaceCount = constructorParams.Count(regularParameterDeclaration => TypesUtil.IsInterfaceType(regularParameterDeclaration.DeclaredElement.Type)); if (interfaceCount > _maxParams) { string message = Stringtable.Warning_TooManyDependencies; var warning = new TooManyDependenciesHighlighting(message); _highlights.Add(new HighlightingInfo(constructorDeclaration.GetNameDocumentRange(), warning)); } }
public virtual void AddInitializeOnLoadMethod(IHighlightingConsumer consumer, IConstructorDeclaration constructorDeclaration, string tooltip) { AddHighlightingWithConfigurableHighlighter(consumer, constructorDeclaration, tooltip); }
/// <summary> /// Returns the text that the constructor should have from the containing type declaration with either with 'less than' and 'greater than' signs escaped or not. /// </summary> /// <param name="constructorDeclaration"> /// The constructor to use. /// </param> /// <param name="encodeHtmlTags"> /// If True then <see cref="ITypeParameterOfTypeDeclaration"/> will have {} instead of < and >. /// </param> /// <returns> /// A string of the text. /// </returns> public static string CreateConstructorDescriptionText(IConstructorDeclaration constructorDeclaration, bool encodeHtmlTags) { ICSharpTypeDeclaration containingTypeDeclaration = constructorDeclaration.GetContainingTypeDeclaration(); string newName = constructorDeclaration.DeclaredName; if (containingTypeDeclaration.TypeParameters.Count > 0) { newName += encodeHtmlTags ? "{" : "<"; for (int i = 0; i < containingTypeDeclaration.TypeParameters.Count; i++) { ITypeParameterOfTypeDeclaration parameterDeclaration = containingTypeDeclaration.TypeParameters[i]; newName += parameterDeclaration.DeclaredName; if (i < containingTypeDeclaration.TypeParameters.Count - 1) { newName += ","; } } newName += encodeHtmlTags ? "}" : ">"; } return newName; }
/// <summary> /// Visits the constructor declaration. /// </summary> /// <param name="constructorDeclaration">The constructor declaration.</param> /// <param name="consumer">The consumer.</param> /// <returns></returns> public override object VisitConstructorDeclaration(IConstructorDeclaration constructorDeclaration, IHighlightingConsumer consumer) { this.VisitTypeMember(constructorDeclaration, consumer); return base.VisitConstructorDeclaration(constructorDeclaration, consumer); }
/// <summary> /// Creates a new summary string for this constructor. /// </summary> /// <param name="constructorDeclaration"> /// The constructor to produce the summary for. /// </param> /// <returns> /// A string of the constructor summary text. /// </returns> public static string CreateSummaryForConstructorDeclaration(IConstructorDeclaration constructorDeclaration) { DeclarationHeader declarationHeader = new DeclarationHeader(constructorDeclaration); if (declarationHeader.IsInherited) { return declarationHeader.XmlNode.InnerXml; } if (!StyleCopOptions.Instance.InsertTextIntoDocumentation) { return string.Empty; } bool parentIsStruct = Utils.IsContainingTypeAStruct(constructorDeclaration); string structOrClass = parentIsStruct ? "struct" : "class"; string xmlWeShouldInsert; if (constructorDeclaration.IsStatic) { xmlWeShouldInsert = string.Format(CultureInfo.InvariantCulture, HeaderSummaryForStaticConstructorXml, constructorDeclaration.DeclaredName, structOrClass); } else if (constructorDeclaration.GetAccessRights() == AccessRights.PRIVATE && constructorDeclaration.ParameterDeclarations.Count == 0) { xmlWeShouldInsert = string.Format( CultureInfo.InvariantCulture, HeaderSummaryForPrivateInstanceConstructorXml, constructorDeclaration.DeclaredName, structOrClass); } else { string constructorDescriptionText = Utils.CreateConstructorDescriptionText(constructorDeclaration, true); xmlWeShouldInsert = string.Format(CultureInfo.InvariantCulture, HeaderSummaryForInstanceConstructorXml, constructorDescriptionText, structOrClass); } return xmlWeShouldInsert; }
protected override void InitializeForCodeGeneration() { base.InitializeForCodeGeneration(); NodeType = NodeType.New; Constructor = default(IConstructorDeclaration); Arguments = new FormulaCollection<Formula>(); }
/// <summary> /// Ensures that the constructor documentation starts with the standard text summary. /// </summary> /// <remarks> /// Keeps the existing comment, but prepends the standard text. /// </remarks> /// <param name="constructorDeclaration"> /// The destructor <see cref="IDeclaration"/>. /// </param> public void EnsureConstructorSummaryDocBeginsWithStandardText(IConstructorDeclaration constructorDeclaration) { if (constructorDeclaration == null) { return; } IContextBoundSettingsStore settingsStore = PsiSourceFileExtensions.GetSettingsStore(null, constructorDeclaration.GetSolution()); if (!settingsStore.GetValue((StyleCopOptionsSettingsKey key) => key.InsertTextIntoDocumentation)) { return; } DeclarationHeader declarationHeader = new DeclarationHeader(constructorDeclaration); if (declarationHeader.IsMissing || declarationHeader.IsInherited || !declarationHeader.HasSummary) { return; } string existingSummaryText = declarationHeader.SummaryXmlNode.InnerXml; bool parentIsStruct = Utils.IsContainingTypeAStruct(constructorDeclaration); int constructorParameterCount = constructorDeclaration.ParameterDeclarations.Count; string xmlComment = Utils.GetTextFromDeclarationHeader(declarationHeader.XmlNode); string structOrClass = parentIsStruct ? CachedCodeStrings.StructText : CachedCodeStrings.ClassText; string textWeShouldStartWith; if (constructorDeclaration.IsStatic) { textWeShouldStartWith = string.Format( CultureInfo.InvariantCulture, CachedCodeStrings.HeaderSummaryForStaticConstructor, constructorDeclaration.DeclaredName, structOrClass); } else if (constructorDeclaration.GetAccessRights() == AccessRights.PRIVATE && constructorParameterCount == 0) { textWeShouldStartWith = string.Format( CultureInfo.InvariantCulture, CachedCodeStrings.HeaderSummaryForPrivateInstanceConstructor, constructorDeclaration.DeclaredName, structOrClass); } else { string constructorDescriptionText = Utils.CreateConstructorDescriptionText(constructorDeclaration, true); textWeShouldStartWith = string.Format( CultureInfo.InvariantCulture, CachedCodeStrings.HeaderSummaryForInstanceConstructor, constructorDescriptionText, structOrClass); } if (constructorDeclaration.IsStatic) { string docStd = string.Format("Initializes the {0} class.", constructorDeclaration.DeclaredName); if (xmlComment == docStd) { existingSummaryText = string.Empty; } } if (!xmlComment.StartsWith(textWeShouldStartWith, StringComparison.Ordinal)) { string newSummaryText = Utils.CreateSummaryForConstructorDeclaration(constructorDeclaration); declarationHeader.SummaryXmlNode.InnerXml = newSummaryText + " " + existingSummaryText; declarationHeader.Update(); } }
public static NewFormula New(IConstructorDeclaration constructor, ReadOnlyCollection<Formula> arguments) { return new NewFormula(constructor, arguments, null); }
private IClassDeclaration CreateInitialViewModel(IClassDeclaration classDeclaration, IFieldDeclaration fieldDeclaration, IConstructorDeclaration viewModelConstructor) { IConstructLanguage language = classDeclaration.Language; IClassDeclaration viewModel = language.Class( language.Modifiers(Modifiers.Public), language.None <IClassTypeParameters>(), language.None <ITypeName>(), new List <ITypeName>(), new List <IDeclaration>() { fieldDeclaration, viewModelConstructor }); NamingPolicy classesPolicy = viewModel.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings); string viewModelName = classesPolicy.MakeTypeNameUniqueInNamespace(classDeclaration, classDeclaration.Identifier.Name + "ViewModel"); viewModel.Identifier = language.Identifier(viewModelName); return(viewModel); }
public static MethodRef CreateConstructorReference(IMethodName methodName, IConstructor ctor, IConstructorDeclaration ctorDecl) { return(new MethodRef { Name = methodName, Constructor = ctor, ConstructorDeclaration = ctorDecl, IsAssemblyReference = false }); }
public ConstructorDeclarationCompiler(IConstructorDeclaration constructorDeclaration, AbstractILCompilerParams @params) : base(@params) { myConstructorDeclaration = constructorDeclaration; MyParams.CreateMethod(constructorDeclaration.DeclaredElement); }
public virtual void AddInitializeOnLoadMethod(IHighlightingConsumer consumer, IConstructorDeclaration constructorDeclaration, string tooltip, string displayName, DaemonProcessKind kind) { AddHighlightingWithConfigurableHighlighter(consumer, constructorDeclaration, tooltip, displayName, kind); }