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;
}
