private static void WriteObjectInitializer(CodeTextBuilder code, ObjectInitializerExpression expression) { if (expression.PropertyValues == null || expression.PropertyValues.Count == 0) { code.Write("{ }"); return; } code.WriteListStart(opener: "{", closer: "}", separator: ",", newLine: true); foreach (var keyValue in expression.PropertyValues) { code.WriteListItem(); code.Write(keyValue.Name.GetSealedOrCased(CasingStyle.Camel, sealLanguage: LanguageInfo.Entries.JavaScript())); if (keyValue.Value is IAssignable assignable && assignable.Name == keyValue.Name) { continue; } code.Write(": "); WriteExpression(code, keyValue.Value); } code.WriteListEnd(); }
/// <summary> /// Determines whether the given expression is the left-hand-side literal in any of the assignment expressions /// within an object initialize expression. /// </summary> /// <param name="expression">The expression to check.</param> /// <returns>Returns true if the expression is the left-hand-side literal in any of the assignment expressions /// within an object initializer expression.</returns> /// <remarks>This method checks for the following situation: /// class MyClass /// { /// public bool Member { get { return true; } } /// public void SomeMethod() /// { /// MyObjectType someObject = new MyObjectType { Member = this.Member }; /// } /// } /// In this case, StyleCop will raise a violation since it looks like the Member token should be prefixed by 'this.', however, /// it is actually referring to a property on the MyObjectType type. /// </remarks> private static bool IsObjectInitializerLeftHandSideExpression(Expression expression) { Param.AssertNotNull(expression, "expression"); // The expression should be a literal expression if it represents the keyword being checked. if (expression.ExpressionType == ExpressionType.Literal) { // The literal should be a child-expression of an assignment expression. AssignmentExpression assignmentExpression = expression.Parent as AssignmentExpression; if (assignmentExpression != null) { // The left-hand-side of the assignment expression should be the literal expression. if (assignmentExpression.LeftHandSide == expression) { // The assignment expression should be the child of an object initializer expression. ObjectInitializerExpression objectInitializeExpression = assignmentExpression.Parent as ObjectInitializerExpression; if (objectInitializeExpression != null) { return(true); } } } } return(false); }
public override void VisitNamespace <TUsingDirective, TNamespace, TClassCollection, TDelegate, TEnum, TInterface, TStructCollection>( INamespace <TUsingDirective, TNamespace, TClassCollection, TDelegate, TEnum, TInterface, TStructCollection> @namespace) { Namespace properties; ObjectInitializerExpression expression = CreateExpression(typeof(Namespace)); expression.CreateObjectExpression.NewExpression.Parameters.Add(CreateArgument(@namespace.Name)); expression.Members.AddIfNotNull(nameof(properties.Classes), @namespace.Classes); UseExpression(expression); }
public override void VisitClassMethod <TAttributeGroup, TDeclaringType, TGenericParameter, TTypeReference, TParameter, TMethodBody>( IClassMethod <TAttributeGroup, TDeclaringType, TGenericParameter, TTypeReference, TParameter, TMethodBody> method) { ClassMethod properties; ObjectInitializerExpression expression = CreateExpression(typeof(ClassMethod)); expression.CreateObjectExpression.NewExpression.Parameters.Add(CreateArgument(method.Name)); expression.Members.AddIfNotNull(nameof(properties.Visibility), method.Visibility); expression.Members.AddIfNotNull(nameof(properties.InheritanceModifier), method.InheritanceModifier); expression.Members.AddIfNotNull(nameof(properties.IsAsync), method.IsAsync); expression.Members.AddIfNotNull(nameof(properties.ReturnType), method.ReturnType); expression.Members.AddIfNotNull(nameof(properties.GenericParameters), method.GenericParameters); expression.Members.AddIfNotNull(nameof(properties.Parameters), method.Parameters); UseExpression(expression); }
public override void VisitClassType <TAttributeGroup, TGenericParameter, TClassReference, TInterfaceReference, TEventCollection, TPropertyCollection, TIndexerCollection, TMethodCollection, TFieldCollection, TConstructor, TOperatorOverload, TConversionOperator, TNestedClassCollection, TNestedDelegate, TNestedEnum, TNestedInterface, TNestedStructCollection, TStaticConstructor, TDestructor>( IClassType <TAttributeGroup, TGenericParameter, TClassReference, TInterfaceReference, TEventCollection, TPropertyCollection, TIndexerCollection, TMethodCollection, TFieldCollection, TConstructor, TOperatorOverload, TConversionOperator, TNestedClassCollection, TNestedDelegate, TNestedEnum, TNestedInterface, TNestedStructCollection, TStaticConstructor, TDestructor> @class) { ClassBody properties; ObjectInitializerExpression expression = CreateExpression(typeof(ClassBody)); expression.Members.AddIfNotNull(nameof(properties.Fields), @class.Fields); expression.Members.AddIfNotNull(nameof(properties.Events), @class.Events); expression.Members.AddIfNotNull(nameof(properties.Properties), @class.Properties); expression.Members.AddIfNotNull( nameof(properties.ExplicitInterfaceProperties), WrapperFactory.CreateClassPropertyCollectionWrapper(@class.Properties).ExplicitInterfaceProperties); expression.Members.AddIfNotNull(nameof(properties.Indexers), @class.Indexers); // expression.Members.AddIfNotNull(nameof(properties.Methods), @class.Methods); UseExpression(expression); }
public override void VisitClass <TNamespace, TDocument, TProject, TSolution, TAttributeGroup, TGenericParameter, TClassReference, TInterfaceReference, TEventCollection, TPropertyCollection, TIndexerCollection, TMethodCollection, TFieldCollection, TConstructor, TOperatorOverload, TConversionOperator, TNestedClassCollection, TNestedDelegate, TNestedEnum, TNestedInterface, TNestedStructCollection, TStaticConstructor, TDestructor>( IClass <TNamespace, TDocument, TProject, TSolution, TAttributeGroup, TGenericParameter, TClassReference, TInterfaceReference, TEventCollection, TPropertyCollection, TIndexerCollection, TMethodCollection, TFieldCollection, TConstructor, TOperatorOverload, TConversionOperator, TNestedClassCollection, TNestedDelegate, TNestedEnum, TNestedInterface, TNestedStructCollection, TStaticConstructor, TDestructor> @class) { Class properties; ObjectInitializerExpression expression = CreateExpression(typeof(Class)); expression.CreateObjectExpression.NewExpression.Parameters.Add(CreateArgument(@class.Name)); expression.Members.AddIfNotNull(nameof(properties.Visibility), @class.Visibility); expression.Members.AddIfNotNull(nameof(properties.GenericParameters), @class.GenericParameters); expression.Members.AddIfNotNull(nameof(properties.BaseClass), @class.BaseClass); VisitClassType(@class); if (Expression.ObjectInitializerExpression != null) { expression.Members.Add(nameof(properties.Body), Expression); } UseExpression(expression); }
private static bool IsInsideInitializerToTypeWithSource(CheckContentAvailabilityEventArgs ea) { _TypeElement = null; _ObjectCreationExpression = ea.Element as ObjectCreationExpression; if (_ObjectCreationExpression == null) { _ObjectCreationExpression = ea.Element.GetParent(LanguageElementType.ObjectCreationExpression) as ObjectCreationExpression; if (_ObjectCreationExpression == null) return false; } _InitializerExpression = _ObjectCreationExpression.ObjectInitializer; if (_InitializerExpression == null) return false; _TypeElement = _ObjectCreationExpression.ObjectType.Resolve(ParserServices.SourceTreeResolver) as ITypeElement; if (_TypeElement == null) return false; return !_TypeElement.InReferencedAssembly; }
private void UseExpression(ObjectInitializerExpression expression) { if (expression.Elements.Count == 0 && expression.Initializers.Count == 0 && expression.Members.Count == 0) { Expression = new Expression() { NewExpression = expression.CreateObjectExpression.NewExpression }; } else { Expression = new Expression() { ObjectInitializerExpression = expression }; } }
private static AbstractExpression ReadObjectInitializer(IObjectOrCollectionInitializerOperation op) { var context = CodeReaderContext.GetContextOrThrow(); var result = new ObjectInitializerExpression { PropertyValues = op.Initializers.Select(readInitializer).ToList() }; return(result); NamedPropertyValue readInitializer(IOperation initOp) { if (initOp is IAssignmentOperation assignment && assignment.Target is IMemberReferenceOperation memberRef) { var property = context.FindMemberOrThrow <AbstractMember>(memberRef.Member); var value = ReadAssignmentValue(assignment); return(new NamedPropertyValue(property.Name, value)); } throw new CodeReadErrorException($"Unrecognized object initializer: {initOp.Syntax}"); } }
private static bool HasMatchingConstructors(ObjectInitializerExpression initializer, ITypeElement typeElement) { ExpressionCollection parameters = initializer.Initializers; IElementCollection foundConstructors = typeElement.FindConstructors(parameters); return foundConstructors != null && foundConstructors.Count > 0; }
public virtual ObjectInitializerExpression RewriteObjectInitializerExpression(ObjectInitializerExpression expression) { return(expression); }
public virtual void VisitObjectInitializerExpression(ObjectInitializerExpression expression) { VisitAbstractExpression(expression); }