FieldContractInfo([NotNull] IFieldDeclaration declaration, [NotNull] IClassLikeDeclaration classLikeDeclaration, [NotNull] IType type) : base( ContractKind.Invariant, type) { this.declaration = declaration; this.classLikeDeclaration = classLikeDeclaration; }
protected override AttributeValue[] GetAttributeValues(IPsiModule module, IFieldDeclaration fieldDeclaration) { return(new[] { new AttributeValue(new ConstantValue(fieldDeclaration.DeclaredName, module)) }); }
public ClassFieldDeclarationCompiler( IFieldDeclaration fieldDeclaration, AbstractILCompilerParams myParams) : base(myParams) { myFieldDeclaration = fieldDeclaration; }
public IEnumerable <FieldInfo> GetUsedFields(object method) { var analyzedMethod = method as IMethodDeclaration; if (analyzedMethod.Body == null) { yield break; } var body = analyzedMethod.Body as IMethodBody; var instructions = body.Instructions.OfType <IInstruction>(); foreach (IInstruction instr in instructions) { IFieldReference fr = instr.Value as IFieldReference; if (fr != null) { IFieldDeclaration def = fr.Resolve(); if (def != null) { yield return(HAL.Converter.Field(def)); } } } yield break; }
internal FSharpFieldProperty([NotNull] IFieldDeclaration declaration, [NotNull] FSharpField field) : base(declaration) { Field = field; ReturnType = FSharpTypesUtil.GetType(field.FieldType, declaration, Module) ?? TypeFactory.CreateUnknownType(Module); }
private IEnumerable <IFieldDeclaration> Flatten(IFieldDeclaration fieldDeclaration) { var declaredType = fieldDeclaration.DeclaredElement.Type as IDeclaredType; if (declaredType == null) { yield break; } var typeElement = declaredType.GetTypeElement().NotNull(); if (typeElement.GetClrName().FullName != "Machine.Specifications.Behaves_like`1") { yield return(fieldDeclaration); yield break; } var substitution = declaredType.GetSubstitution(); var typeArguments = substitution.Domain; var behaviorTypes = typeArguments.SelectMany(x => substitution[x].GetTypeElement().NotNull().GetDeclarations()).OfType <IClassDeclaration>(); foreach (var nestedField in behaviorTypes.SelectMany(x => x.FieldDeclarations.SelectMany(Flatten))) { yield return(nestedField); } }
public override void VisitFieldDeclaration(IFieldDeclaration decl, SST sst) { if (decl.DeclaredElement != null) { var name = decl.DeclaredElement.GetName <IFieldName>(); sst.Fields.Add(new FieldDeclaration { Name = name }); if (decl.Initializer != null) { var m = name.IsStatic ? GetClassInit(sst) : GetInit(sst); var vis = name.IsStatic ? _cinitVisitor : _initVisitor; var varRef = name.IsStatic ? new VariableReference() : new VariableReference { Identifier = "this" }; var varInit = decl.Initializer as IVariableInitializer; m.Body.Add( new Assignment { Reference = new FieldReference { FieldName = name, Reference = varRef }, Expression = vis.ToAssignableExpr(varInit, m.Body) }); } } }
private void ConfirmPropertyDeclarationsToBeWrappedAndContinueWrapping(IClassDeclaration classDeclaration, IConstructEnumerable <IMemberDeclaration> propertiesForWrapping) { List <string> confirmedPropertiesNamesForWrapping = new List <string>(); foreach (IMemberDeclaration propertyDeclaration in propertiesForWrapping) { if (classDeclaration.FileModel.UIProcess.Get <ConfirmOccurencesDialog>().Confirm(propertyDeclaration, true)) { confirmedPropertiesNamesForWrapping.Add(propertyDeclaration.Identifier.Name); } } if (propertiesSelectedByUser) { string classDeclarationFullName = classDeclaration.FullName; IClassDeclaration viewModel = CreateViewModelWithoutUserSelectedProperties(classDeclaration); viewModel = RebuildSolutionModel(classDeclaration, viewModel.Identifier.Name); IFieldDeclaration wrappedField = viewModel.ContainedDeclarations.First(d => d.Is <IFieldDeclaration>()).As <IFieldDeclaration>(); IMethodDeclaration onPropertyChangedMethod = viewModel.ContainedDeclarations.First(d => d.Is <IMethodDeclaration>()).As <IMethodDeclaration>(); classDeclaration = viewModel.FileModel.All <IClassDeclaration>().First(c => string.Equals(c.FullName, classDeclarationFullName, System.StringComparison.Ordinal)); List <IPropertyDeclaration> confirmedPropertiesForWrapping = GetPropertiesForWrappingByName(classDeclaration, confirmedPropertiesNamesForWrapping); InsertWrappedProperties(viewModel, confirmedPropertiesForWrapping, wrappedField, onPropertyChangedMethod.Identifier); viewModel.NavigateTo(); } else { propertiesSelectedByUser = true; } }
private bool CanBeConvertToStringEmpty(IStringLiteral literal) { IFieldDeclaration field = literal.Enclosing <IFieldDeclaration>(); if (field.Exists && field.Modifiers.Modifiers.IsConst()) { return(false); } IVariableDeclaration variable = literal.Enclosing <IVariableDeclaration>(); if (variable.Exists && variable.IsConst) { return(false); } IAttribute attributes = literal.Enclosing <IAttribute>(); if (attributes.Exists) { return(false); } return(true); }
private void AddInitializer([NotNull] IFieldDeclaration fieldDeclaration, [NotNull] string initializerExpression) { var logCreateExpression = factory.CreateExpression(initializerExpression); var logInitializer = factory.CreateExpressionInitializer(logCreateExpression); fieldDeclaration.SetInitial(logInitializer); }
public override bool Equals(object obj) { if (this == obj) { return(true); } IFieldDeclaration reference = obj as IFieldDeclaration; if (reference == null) { return(false); } if (this.DeclaringType.Equals(reference.DeclaringType) && this.Name.Equals(reference.Name) && this.FieldType.Equals(reference.FieldType)) { return(true); } else { return(false); } }
/// <summary> /// Gets the VariableInformation attribute of ivd, or creates one if it doesn't already exist /// </summary> internal static VariableInformation GetVariableInformation(BasicTransformContext context, object target) { IVariableDeclaration ivd = null; if (target is IVariableDeclaration) { ivd = (IVariableDeclaration)target; } else if (target is IParameterDeclaration) { IParameterDeclaration ipd = (IParameterDeclaration)target; ivd = Builder.VarDecl(ipd.Name, ipd.ParameterType); } else if (target is IFieldDeclaration) { IFieldDeclaration ifd = (IFieldDeclaration)target; ivd = Builder.VarDecl(ifd.Name, ifd.FieldType); } else { throw new ArgumentException("target is not a variable or parameter"); } VariableInformation vi = context.InputAttributes.Get <VariableInformation>(target); if (vi == null) { vi = new VariableInformation(ivd); context.InputAttributes.Set(target, vi); } return(vi); }
public static ICollection GetFields(ITypeDeclaration value, IVisibilityConfiguration visibility) { IFieldDeclarationCollection fields = value.Fields; ICollection result; if (fields.Count > 0) { ArrayList arrayList = new ArrayList(0); foreach (object obj in fields) { IFieldDeclaration value2 = (IFieldDeclaration)obj; if (visibility == null || IsVisible(value2, visibility)) { arrayList.Add(value2); } } arrayList.Sort(); result = arrayList; } else { result = new IFieldDeclaration[0]; } return(result); }
private FrugalLocalList <IAttribute> GetExistingFormerlySerializedAsAttributes( IFieldDeclaration fieldDeclaration, string nameArgument) { var list = new FrugalLocalList <IAttribute>(); foreach (var attribute in fieldDeclaration.AttributesEnumerable) { var attributeTypeElement = attribute.TypeReference?.Resolve().DeclaredElement as ITypeElement; if (attributeTypeElement == null) { continue; } if (Equals(attributeTypeElement.GetClrName(), KnownTypes.FormerlySerializedAsAttribute)) { var attributeInstance = attribute.GetAttributeInstance(); var nameParameter = attributeInstance.PositionParameter(0); if (nameParameter.IsConstant && nameParameter.ConstantValue.IsString() && (string)nameParameter.ConstantValue.Value == nameArgument) { list.Add(attribute); } } } return(list); }
/// <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); IBlock containingBlock = element.GetContainingNode <IBlock>(true); if (containingBlock != null) { //// CSharpFormatterHelper.FormatterInstance.Format(containingBlock); ICSharpCodeFormatter codeFormatter = (ICSharpCodeFormatter)CSharpLanguage.Instance.LanguageService().CodeFormatter; codeFormatter.Format(containingBlock); new LayoutRules().CurlyBracketsForMultiLineStatementsMustNotShareLine(containingBlock); } else { IFieldDeclaration fieldDeclarationNode = element.GetContainingNode <IFieldDeclaration>(true); if (fieldDeclarationNode != null) { //// CSharpFormatterHelper.FormatterInstance.Format(fieldDeclarationNode); ICSharpCodeFormatter codeFormatter = (ICSharpCodeFormatter)CSharpLanguage.Instance.LanguageService().CodeFormatter; codeFormatter.Format(fieldDeclarationNode); new LayoutRules().CurlyBracketsForMultiLineStatementsMustNotShareLine(fieldDeclarationNode); } } }
public FieldInfo Field(IFieldDeclaration fieldDefinition, TypeInfo type) { if (_fieldCorrespondence.ContainsKey(fieldDefinition)) { return(_fieldCorrespondence[fieldDefinition]); } var fieldInfo = new FieldInfo { Text = fieldDefinition.ToString(), Name = fieldDefinition.Name, FullName = fieldDefinition.Name, IsInternal = fieldDefinition.Visibility == FieldVisibility.Assembly, IsPrivate = fieldDefinition.Visibility == FieldVisibility.Private, IsPublic = fieldDefinition.Visibility == FieldVisibility.Public, IsProtected = fieldDefinition.Visibility == FieldVisibility.Family, IsProtectedAndInternal = fieldDefinition.Visibility == FieldVisibility.FamilyAndAssembly, IsProtectedOrInternal = fieldDefinition.Visibility == FieldVisibility.FamilyOrAssembly, IsStatic = fieldDefinition.Static, IsLiteral = fieldDefinition.Literal, IsInitOnly = fieldDefinition.ReadOnly, IsSpecialName = fieldDefinition.SpecialName, MemberReference = fieldDefinition, DeclaringType = type }; _fieldCorrespondence.Add(fieldDefinition, fieldInfo); fieldInfo.Text = fieldInfo.Text.Substring(fieldInfo.Text.LastIndexOf('.') + 1); fieldInfo.Name = fieldInfo.Name.Substring(fieldInfo.Name.LastIndexOf('.') + 1); fieldInfo.Icon = Images.Images.GetFieldIcon(fieldInfo); return(fieldInfo); }
public void WriteFieldDeclaration(IFieldDeclaration fieldDeclaration, IFormattedCodeWriter writer) { writer.WriteKeyword(".field "); if (fieldDeclaration.Visibility == FieldVisibility.Public) { writer.WriteKeyword("public "); } else if (fieldDeclaration.Visibility == FieldVisibility.Private) { writer.WriteKeyword("private "); } else if (fieldDeclaration.Visibility == FieldVisibility.Assembly) { writer.WriteKeyword("assembly "); } else if (fieldDeclaration.Visibility == FieldVisibility.Family) { writer.WriteKeyword("family "); } else if (fieldDeclaration.Visibility == FieldVisibility.FamilyAndAssembly) { writer.WriteKeyword("family assembly "); } else if (fieldDeclaration.Visibility == FieldVisibility.FamilyOrAssembly) { writer.WriteKeyword("famorassem "); } if (fieldDeclaration.IsStatic) { writer.WriteKeyword("static "); } if (fieldDeclaration.IsConst) { writer.WriteKeyword("literal "); } else if (fieldDeclaration.IsReadOnly) { writer.WriteKeyword("initonly "); } WriteTypeReference(fieldDeclaration.FieldType, fieldDeclaration.FieldType.Assembly, writer); writer.Write(' '); writer.WriteIdentifier(fieldDeclaration.Name); if (fieldDeclaration.IsConst) { writer.Write(" = "); WriteTypeReference(fieldDeclaration.FieldType, fieldDeclaration.FieldType.Assembly, writer); writer.Write('('); writer.Write(fieldDeclaration.Initialiser.Value.ToString()); writer.Write(')'); } writer.WriteLine(); }
public override void Visit(IFieldDeclaration stmt, StringBuilder sb) { sb.Append("\t"); sb.Append(stmt.Name.ValueType.Name); sb.Append(" "); sb.Append(stmt.Name.Name); sb.Append(";\n"); }
public FieldDefinition GetFieldDefinition(IFieldDeclaration item) { return(TryGetOrAdd(_fieldcache, item, fdef => { var tdef = GetTypeDefinition(item.DeclaringType as ITypeDeclaration); return tdef == null ? null : ReflectorHelper.FindMatchingField(tdef, fdef); })); }
public ToggleHideInInspectorOne(IFieldDeclaration fieldDeclaration, IPsiModule psiModule, CSharpElementFactory elementFactory, IAttribute existingAttribute) { myFieldDeclaration = fieldDeclaration; myPsiModule = psiModule; myElementFactory = elementFactory; myExistingAttribute = existingAttribute; }
public RemoveAttributeAction(IMultipleFieldDeclaration multipleFieldDeclaration, [CanBeNull] IFieldDeclaration selectedFieldDeclaration, IAttribute existingAttribute) { myMultipleFieldDeclaration = multipleFieldDeclaration; mySelectedFieldDeclaration = selectedFieldDeclaration; myExistingAttribute = existingAttribute; }
public FieldDefinition GetFieldDefinition(IFieldDeclaration item) { return TryGetOrAdd(_fieldcache, item, fdef => { var tdef = GetTypeDefinition(item.DeclaringType as ITypeDeclaration); return tdef == null ? null : ReflectorHelper.FindMatchingField(tdef, fdef); }); }
public ToggleSerializedFieldOne(IFieldDeclaration fieldDeclaration, IPsiModule module, CSharpElementFactory elementFactory, bool isSerialized) { myFieldDeclaration = fieldDeclaration; myModule = module; myElementFactory = elementFactory; myIsSerialized = isSerialized; }
object Find(IFieldDeclaration fieldDecl) { if (String.Equals(element.MemberName, fieldDecl.Name, StringComparison.InvariantCulture) && (element.MemberReturnType == null || Is(fieldDecl.FieldType, element.MemberReturnType))) { return(fieldDecl); } return(null); }
public ToggleSerializedFieldAll(IMultipleFieldDeclaration multipleFieldDeclaration, IPsiModule module, CSharpElementFactory elementFactory, bool isSerialized) { myMultipleFieldDeclaration = multipleFieldDeclaration; myFieldDeclaration = (IFieldDeclaration)multipleFieldDeclaration.Declarators[0]; myModule = module; myElementFactory = elementFactory; myIsSerialized = isSerialized; }
private void RemoveExistingAttributesWithNewName(IFieldDeclaration fieldDeclaration) { var attributes = GetExistingFormerlySerializedAsAttributes(fieldDeclaration, NewName); foreach (var attribute in attributes) { fieldDeclaration.RemoveAttribute(attribute); } }
private IFieldDeclaration CreateFieldToHoldWrappedClass(IConstructLanguage language, ITypeName typeName, IClassDeclaration classDeclaration) { IFieldDeclaration fieldDeclaration = language.Field(language.Modifiers(Modifiers.Private | Modifiers.Readonly), typeName); NamingPolicy fieldsNamingPolicy = fieldDeclaration.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings); string fieldName = fieldsNamingPolicy.ChangeNameAccordingToPolicy(classDeclaration.Identifier.Name, classDeclaration.SolutionModel); fieldDeclaration.Identifier = language.Identifier(fieldName); return(fieldDeclaration); }
public IFieldDeclaration Anonymize(IFieldDeclaration d) { var defaultName = Names.UnknownField; var isDefaultName = defaultName.Equals(d.Name); return(new FieldDeclaration { Name = isDefaultName ? defaultName : d.Name.ToAnonymousName() }); }
private static void AddKeywords([NotNull] IFieldDeclaration fieldDeclaration, [NotNull] params TokenNodeType[] keywords) { fieldDeclaration.SetModifiersList((IModifiersList)ElementType.MODIFIERS_LIST.Create()); foreach (var keyword in keywords) { fieldDeclaration.ModifiersList.AddModifier((ITokenNode)keyword.CreateLeafElement()); } }
private static bool FieldMatches(FieldDefinition fdef, IFieldDeclaration fdec) { // Compatible with alteration feature !!! // Called only the first time then in cache, so even if code is altered, this will work // No need to check the declaring type, if we are here, they are in sync return((fdef != null) && (fdec != null) && fdef.Name.Equals(fdec.Name)); }
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); }
public static FieldOrPropertyDeclaration FromFieldDeclaration(IFieldDeclaration fieldDeclaration) { Contract.Requires(fieldDeclaration != null); Contract.Requires(fieldDeclaration.NameIdentifier != null); Contract.Requires(fieldDeclaration.DeclaredElement != null); return new FieldOrPropertyDeclaration { IsStatic = fieldDeclaration.IsStatic, Name = fieldDeclaration.NameIdentifier.Name, Type = fieldDeclaration.DeclaredElement.Type, Field = fieldDeclaration, }; }
internal ContractPublicPropertyNameHighlighing(IFieldDeclaration fieldDeclaration, string referingFieldOrPropertyName, ICSharpTypeMemberDeclaration referingFieldOrProperty) { Contract.Requires(fieldDeclaration != null); Contract.Requires(referingFieldOrPropertyName != null); _fieldDeclaration = fieldDeclaration; _referingFieldOrProperty = referingFieldOrProperty; FieldName = fieldDeclaration.NameIdentifier.With(x => x.Name); PropertyName = referingFieldOrPropertyName; FieldType = fieldDeclaration.Type.GetLongPresentableName(CSharpLanguage.Instance); }
public static FieldDefinition FindMatchingField(TypeDefinition typedef, IFieldDeclaration fdec) { return typedef.Fields.FirstOrDefault(fdef => FieldMatches(fdef, fdec)); }
private static bool FieldMatches(FieldDefinition fdef, IFieldDeclaration fdec) { // Compatible with alteration feature !!! // Called only the first time then in cache, so even if code is altered, this will work // No need to check the declaring type, if we are here, they are in sync return (fdef != null) && (fdec != null) && (fdef.Name.Equals(fdec.Name)); }
public FieldInfo Field(IFieldDeclaration fieldDefinition, TypeInfo type) { if (_fieldCorrespondence.ContainsKey(fieldDefinition)) { return _fieldCorrespondence[fieldDefinition]; } var fieldInfo = new FieldInfo { Text = fieldDefinition.ToString(), Name = fieldDefinition.Name, FullName = fieldDefinition.Name, IsInternal = fieldDefinition.Visibility == FieldVisibility.Assembly, IsPrivate = fieldDefinition.Visibility == FieldVisibility.Private, IsPublic = fieldDefinition.Visibility == FieldVisibility.Public, IsProtected = fieldDefinition.Visibility == FieldVisibility.Family, IsProtectedAndInternal = fieldDefinition.Visibility == FieldVisibility.FamilyAndAssembly, IsProtectedOrInternal = fieldDefinition.Visibility == FieldVisibility.FamilyOrAssembly, IsStatic = fieldDefinition.Static, IsLiteral = fieldDefinition.Literal, IsInitOnly = fieldDefinition.ReadOnly, IsSpecialName = fieldDefinition.SpecialName, MemberReference = fieldDefinition, DeclaringType = type }; _fieldCorrespondence.Add(fieldDefinition, fieldInfo); fieldInfo.Text = fieldInfo.Text.Substring(fieldInfo.Text.LastIndexOf('.') + 1); fieldInfo.Name = fieldInfo.Name.Substring(fieldInfo.Name.LastIndexOf('.') + 1); fieldInfo.Icon = Images.Images.GetFieldIcon(fieldInfo); return fieldInfo; }
protected internal FieldFormula(Formula instance, IFieldDeclaration field) : base(NodeType.Field, field.FieldType, instance, field) { }
private bool IsEnumerationElement(IFieldDeclaration value) { IType fieldType = value.FieldType; IType declaringType = value.DeclaringType; if (fieldType.Equals(declaringType)) { ITypeReference typeReference = fieldType as ITypeReference; if (typeReference != null) { return Helper.IsEnumeration(typeReference); } } return false; }
private void InsertWrappedProperties(IClassDeclaration viewModel, List<IPropertyDeclaration> confirmedPropertiesForWrapping, IFieldDeclaration wrappedClassField, IIdentifier onPropertyChangedIdentifier) { IConstructLanguage language = viewModel.Language; foreach (IPropertyDeclaration property in confirmedPropertiesForWrapping) { IMemberAccess propertyMemberAccess = language.MemberAccess( language.MemberAccess(language.None<IExpression>(), wrappedClassField.Identifier), property.Identifier); IAccessor getterOfWrapper = language.None<IAccessor>(); IAccessor propertyGetter = property.Getter(); if (propertyGetter.Exists && IsAccessorVisibleOutsideClass(propertyGetter.Modifiers)) { getterOfWrapper = language.Getter( language.Modifiers(propertyGetter.Modifiers.Modifiers), language.Block( language.ReturnStatement(propertyMemberAccess))); } IAccessor setterOfWrapper = language.None<IAccessor>(); IAccessor propertySetter = property.Setter(); if (propertySetter.Exists && IsAccessorVisibleOutsideClass(propertySetter.Modifiers)) { IStatement assignment = language.AssignmentStatement(propertyMemberAccess, language.Expression("value")); IMethodInvocation onPropertyChangedInvocation = language.MethodInvocation( language.None<IExpression>(), onPropertyChangedIdentifier, language.None<ITypeArguments>(), language.Arguments( language.Argument(language.StringLiteral(property.Identifier.Name)))); IIfStatement ifStatement = language.IfStatement( language.BinaryExpression(propertyMemberAccess, Operator.NotEqual, language.Expression("value")), language.Block(assignment, language.ExpressionStatement(onPropertyChangedInvocation))); setterOfWrapper = language.Setter( language.Modifiers(propertyGetter.Modifiers.Modifiers), language.Block(ifStatement)); } if (getterOfWrapper.Exists || setterOfWrapper.Exists) { IPropertyDeclaration wrapperProperty = language.Property( language.None<IDocComment>(), language.None<IAttributes>(), property.Modifiers, property.TypeName, property.Identifier, getterOfWrapper, setterOfWrapper); viewModel.Insert(wrapperProperty); } } }
public void WriteFieldDeclaration(IFieldDeclaration value) { if ((configuration["ShowCustomAttributes"] == "true") && (value.Attributes.Count != 0)) { this.WriteCustomAttributeList(value, formatter); formatter.WriteLine(); } if (!this.IsEnumerationElement(value)) { WriteFieldVisibility(value.Visibility, formatter); if ((value.Static) && (value.Literal)) { formatter.WriteKeyword("const"); formatter.Write(" "); } else { if (value.Static) { formatter.WriteKeyword("class var"); formatter.Write(" "); } if (value.ReadOnly) { formatter.WriteKeyword("{readonly}"); formatter.Write(" "); } } this.WriteDeclaration(value.Name, value, formatter); formatter.Write(": "); this.WriteType(value.FieldType, formatter); } else { this.WriteDeclaration(value.Name, value, formatter); } byte[] data = null; IExpression initializer = value.Initializer; if (initializer != null) { ILiteralExpression literalExpression = initializer as ILiteralExpression; if ((literalExpression != null) && (literalExpression.Value != null) && (literalExpression.Value is byte[])) { data = (byte[])literalExpression.Value; } else { formatter.Write(" = "); this.WriteExpression(initializer, formatter); } } if (!this.IsEnumerationElement(value)) { formatter.Write(";"); } if (data != null) { this.formatter.WriteComment(" // data size: " + data.Length.ToString(CultureInfo.InvariantCulture) + " bytes"); } this.WriteDeclaringType(value.DeclaringType as ITypeReference, formatter); }
FieldContractInfo([NotNull] IFieldDeclaration declaration, [NotNull] IClassLikeDeclaration classLikeDeclaration, [NotNull] IType type) : base(ContractKind.Invariant, type) { this.declaration = declaration; this.classLikeDeclaration = classLikeDeclaration; }
protected override void InitializeForCodeGeneration() { base.InitializeForCodeGeneration(); NodeType = NodeType.Field; Member = default(IFieldDeclaration); }
public virtual void VisitFieldDeclaration(IFieldDeclaration value) { this.VisitCustomAttributeCollection(value.Attributes); this.VisitType(value.FieldType); }
//private bool ComareIEventReference(IEventReference o, IEventReference n) //{ // if (o == null && n== null) // return true; // if (o == null || n== null) // return false; // return (o.DeclaringType.ToString() == n.DeclaringType.ToString() && // o.EventType.Compare(n.EventType) && // o.GenericEvent. //} private bool CheckFieldDecl(IFieldDeclaration o, IFieldDeclaration n) { if (!o.Attributes.Compare(n.Attributes, CheckCustomAttribute)) return false; if (o.DeclaringType.ToString() != n.DeclaringType.ToString()) return false; if (o.FieldType.ToString() != n.FieldType.ToString()) return false; if (o.Initializer != null && n.Initializer != null) { if (o.Initializer.ToString() != n.Initializer.ToString()) return false; } if (o.Literal != n.Literal) return false; if (o.Name != n.Name) return false; if (o.ReadOnly != n.ReadOnly) return false; if (o.RuntimeSpecialName != n.RuntimeSpecialName) return false; if (o.SpecialName != n.SpecialName) return false; if (o.Static != n.Static) return false; if (o.Visibility != n.Visibility) return false; return true; }
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 static bool IsFieldDeclarationValid(IFieldDeclaration fieldDeclaration) { // TODO: when field is valid? return true; }
private IAccessor CreateSetter(IConstructLanguage language, string propertyName, IFieldDeclaration field) { string propertyChangedName = language.Name == LanguageNames.CSharp ? "OnPropertyChanged" : "RaisePropertyChangedEvent"; IMethodInvocation onPropertyChanged = language.MethodInvocation(language.None<IExpression>(), language.Identifier(propertyChangedName), language.None<ITypeArguments>(), language.Arguments( language.Argument(language.StringLiteral(propertyName)))); IMemberAccess fieldUsage = language.MemberAccess(language.None<IExpression>(), field.Identifier); IExpression valueUsage = language.Expression("value"); IStatement assignment = language.AssignmentStatement(fieldUsage, valueUsage); IIfStatement ifStatement = language.IfStatement( language.BinaryExpression(fieldUsage, Operator.NotEqual, valueUsage), language.Block(assignment, language.ExpressionStatement(onPropertyChanged))); IAccessor setter = language.Setter(language.Block(ifStatement)); return setter; }
public static FieldFormula Field(Formula instance, IFieldDeclaration field) { return new FieldFormula(instance, field); }
public virtual IFieldDeclarationCollection TransformFieldDeclarationCollection(IFieldDeclarationCollection fields) { IFieldDeclaration[] array = new IFieldDeclaration[fields.Count]; for (int i = 0; i < fields.Count; i++) { array[i] = this.TransformFieldDeclaration(fields[i]); } IFieldDeclarationCollection target = new FieldDeclarationCollection(); target.AddRange(array); return target; }
bool IsNonSerialized(IFieldDeclaration field) { foreach (ICustomAttribute attr in field.Attributes) { if (((ITypeReference)attr.Constructor.DeclaringType).Name.Equals("NonSerializedAttribute")) { return true; } } return false; }
public virtual IFieldDeclaration TransformFieldDeclaration(IFieldDeclaration value) { this.InsituTransformCustomAttributeCollection(value.Attributes); return value; }