// Fields there is only on Classes or Structs
public override void VisitFieldDeclaration(FieldDeclaration fd)
{
ClassesAndStructs cs = (ClassesAndStructs)GetDeclarationFor(fd);
string name = fd.Variables.Single().Name;
string returnType = fd.ReturnType.ToString();
Visibility v = new Visibility(VisibilityMapper.Map(fd.Modifiers));
if (al.CheckFlag(fd.Modifiers, Modifiers.Const))
{
Constant cf = new Constant(v, name, returnType, fd.Variables.Single().Initializer.ToString());
cs.ConstantFields.Add(cf);
}
else
{
Field f = new Field(v, name,
al.CheckFlag(fd.Modifiers, Modifiers.Static),
al.CheckFlag(fd.Modifiers, Modifiers.Readonly),
returnType
);
cs.Fields.Add(f);
}
AddToNotDefaultReferencedTypes(cs, returnType);
// call base to forward execution
base.VisitFieldDeclaration(fd);
}
public void Run (RefactoringContext context)
{
var property = context.GetNode<PropertyDeclaration> ();
string backingStoreName = context.GetNameProposal (property.Name);
// create field
var backingStore = new FieldDeclaration ();
backingStore.ReturnType = property.ReturnType.Clone ();
var initializer = new VariableInitializer (backingStoreName);
backingStore.Variables.Add (initializer);
// create new property & implement the get/set bodies
var newProperty = (PropertyDeclaration)property.Clone ();
var id1 = new IdentifierExpression (backingStoreName);
var id2 = new IdentifierExpression (backingStoreName);
newProperty.Getter.Body = new BlockStatement () {
new ReturnStatement (id1)
};
newProperty.Setter.Body = new BlockStatement () {
new ExpressionStatement (new AssignmentExpression (id2, AssignmentOperatorType.Assign, new IdentifierExpression ("value")))
};
using (var script = context.StartScript ()) {
script.Replace (property, newProperty);
script.InsertBefore (property, backingStore);
script.Link (initializer, id1, id2);
}
}
/// <summary>
/// Adds the elements of an array to the end of this FieldDeclarationCollection.
/// </summary>
/// <param name="items">
/// The array whose elements are to be added to the end of this FieldDeclarationCollection.
/// </param>
public virtual void AddRange(FieldDeclaration[] items)
{
foreach (FieldDeclaration item in items)
{
this.List.Add(item);
}
}
public override void ExtendDeclaration(IDeclarationModel declaration, CompilationModel model)
{
// this only applies to properties
var propDecl = declaration as PropertyDeclaration;
if (propDecl == null || propDecl.Container == null)
return;
var container = propDecl.Container;
container.RemoveMember(propDecl);
var field = new FieldDeclaration
{
Container = container,
OriginatingNode = propDecl.OriginatingNode,
OriginatingTree = propDecl.OriginatingTree,
Definition = new FieldDefinition
{
Name = propDecl.Name,
ContainingType = propDecl.Definition.ContainingType,
Kind = DefinitionKind.Member,
MemberKind = MemberDefinitionKind.Field,
Type = propDecl.Definition.Type
}
};
field.Definition.Modifiers.Apply(propDecl.Definition.Modifiers);
container.AddMember(field);
}
void GenerateNewScript(Script script, FieldDeclaration fieldDeclaration, RefactoringContext context)
{
var firstOrNullObject = fieldDeclaration.Variables.FirstOrNullObject();
if(firstOrNullObject==null)
return;
var matchedNodes = ComputeMatchNodes(context, firstOrNullObject);
foreach (var matchNode in matchedNodes)
{
var parent = matchNode.Parent;
if (matchNode is VariableInitializer)
{
script.Remove(parent);
}
else
if (matchNode is IdentifierExpression)
{
if(parent is AssignmentExpression)
{
script.Remove(parent.Parent);
}
else
{
var clone = (IdentifierExpression)matchNode.Clone();
clone.Identifier = "TODO";
script.Replace(matchNode, clone);
}
}
}
}
public override void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
{
CLRType t = m_clrTypes.Value.Last.Value;
string name = fieldDeclaration.Variables.Single().Name;
string returnType = fieldDeclaration.ReturnType.ToString();
Visibility v = new Visibility(VisibilityMapper.Map(fieldDeclaration.Modifiers));
if (CheckFlag(fieldDeclaration.Modifiers, Modifiers.Const))
{
ConstField cf = new ConstField(v, name, returnType, fieldDeclaration.Variables.Single().Initializer.ToString());
t.ConstantFields.Add(cf); // connect
}
else
{
Field f = new Field(
CheckFlag(fieldDeclaration.Modifiers, Modifiers.Static),
CheckFlag(fieldDeclaration.Modifiers, Modifiers.Readonly),
v,
CheckFlag(fieldDeclaration.Modifiers, Modifiers.Virtual),
name,
CheckFlag(fieldDeclaration.Modifiers, Modifiers.Abstract),
returnType
);
t.Fields.Add(f); // connect
}
AddToNotDefaultReferencedTypes(returnType);
// call base to forward execution
base.VisitFieldDeclaration(fieldDeclaration);
}
internal FieldDeclaration AddFieldForLocal(SimpleName localName, Expression initialValue, ISourceLocation sourceLocation) {
FieldDeclaration field = new FieldDeclaration(null, FieldDeclaration.Flags.Static, TypeMemberVisibility.Private,
TypeExpression.For(initialValue.Type), new NameDeclaration(localName.Name, localName.SourceLocation), null, sourceLocation);
field.SetContainingTypeDeclaration(this, false);
this.members.Add(field);
this.localFieldFor.Add(localName.Name.UniqueKeyIgnoringCase, field.FieldDefinition);
return field;
}
public override void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
{
if (fieldDeclaration.HasModifier(Modifiers.Static))
{
this.CheckDependency(fieldDeclaration.ReturnType);
base.VisitFieldDeclaration(fieldDeclaration);
}
}
public override object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
{
if ((fieldDeclaration.Modifiers & Modifiers.Const) == Modifiers.Const)
{
UnlockWith(fieldDeclaration);
}
return base.VisitFieldDeclaration(fieldDeclaration, data);
}
public void Verify()
{
FieldDeclaration field = new FieldDeclaration("_customer", new CodeDomTypeReference(typeof(int)));
Assert.AreEqual("_customer", field.Name);
field.Initialize = true;
CodeMemberField codefield = field.ToCodeDom();
Assert.AreEqual("_customer", codefield.Name);
Assert.AreEqual("System.Int32", codefield.Type.BaseType);
}
internal void AddStandardMembers(Compilation compilation, List<Statement> bodyOfMainRoutine) {
NameDeclaration labelOfFirstStatement = new NameDeclaration(compilation.NameTable.GetNameFor("<<first statement>>"), SourceDummy.SourceLocation);
FieldDeclaration labelField = new FieldDeclaration(null, 0, TypeMemberVisibility.Private,
TypeExpression.For(compilation.PlatformType.SystemInt32.ResolvedType), labelOfFirstStatement, null, SourceDummy.SourceLocation);
this.members.Add(labelField);
this.AddMainMethod(compilation, bodyOfMainRoutine, labelField);
this.AddEntryPointMethod(compilation);
this.AddConstructor(compilation);
}
public FieldReferenceExpression(Expression target,FieldDeclaration field)
{
if (target==null)
throw new ArgumentNullException("target");
if (field==null)
throw new ArgumentNullException("field");
this.target = target;
this.declaringField = field;
}
private void AddMainMethod(Compilation compilation, List<Statement> bodyOfMainRoutine, FieldDeclaration labelField) {
MethodDeclaration mainMethod = new MethodDeclaration(null, 0, TypeMemberVisibility.Public,
TypeExpression.For(compilation.PlatformType.SystemVoid.ResolvedType), null, new NameDeclaration(compilation.NameTable.GetNameFor("Main"), SourceDummy.SourceLocation), null,
null, null, new BlockStatement(bodyOfMainRoutine, this.SourceLocation), this.SourceLocation);
bodyOfMainRoutine.Add(new SwitchStatement(new SimpleName(labelField.Name, SourceDummy.SourceLocation, false), this.cases, SourceDummy.SourceLocation));
bodyOfMainRoutine.Add(new LabeledStatement(new NameDeclaration(labelField.Name, SourceDummy.SourceLocation), new EmptyStatement(false, SourceDummy.SourceLocation), SourceDummy.SourceLocation));
this.AddLabel(new SimpleName(labelField.Name, SourceDummy.SourceLocation, false));
this.members.Add(mainMethod);
this.mainMethod = mainMethod;
}
public static OverloadsCollection Create(IEmitter emitter, FieldDeclaration fieldDeclaration)
{
string key = fieldDeclaration.GetHashCode().ToString();
if (emitter.OverloadsCache.ContainsKey(key))
{
return emitter.OverloadsCache[key];
}
return new OverloadsCollection(emitter, fieldDeclaration);
}
protected FieldDeclaration GetFieldDeclaration(String name, AstType propertyType)
{
var declaration = new FieldDeclaration();
declaration.Name = name;
declaration.Modifiers = Modifiers.Public;
declaration.ReturnType = propertyType;
IDELogger.Log("BaseRefactoringDialog::GetFieldDeclaration -- {0}", declaration.Name);
return declaration;
}
public static List<CSField> Parse(FieldDeclaration fieldNode)
{
var returnList = new List<CSField>();
EnumProtectionLevel protectionLevel = EnumProtectionLevel.None;
if ((fieldNode.Modifiers & Modifiers.Public) == Modifiers.Public)
{
protectionLevel = EnumProtectionLevel.Public;
}
else if ((fieldNode.Modifiers & Modifiers.Private) == Modifiers.Private)
{
protectionLevel = EnumProtectionLevel.Private;
}
else if ((fieldNode.Modifiers & Modifiers.Protected) == Modifiers.Protected)
{
protectionLevel = EnumProtectionLevel.Protected;
}
else if ((fieldNode.Modifiers & Modifiers.Internal) == Modifiers.Internal)
{
protectionLevel = EnumProtectionLevel.Internal;
}
string typeName;
string typeNamespace;
DotNetParserHelper.SplitType(fieldNode.ReturnType.ToString(), out typeName, out typeNamespace);
foreach(VariableInitializer variableNode in fieldNode.Variables)
{
CSField fieldObject = new CSField
{
TypeNamespace = typeNamespace,
TypeName = typeName,
FieldName = variableNode.Name,
ProtectionLevel = protectionLevel
};
if(variableNode.Initializer != null)
{
if(variableNode.Initializer is PrimitiveExpression)
{
PrimitiveExpression primitiveExpression = (PrimitiveExpression)variableNode.Initializer;
fieldObject.FieldValue = primitiveExpression.Value;
}
}
foreach (var attributeSectionNode in fieldNode.Attributes)
{
foreach (var attributeNode in attributeSectionNode.Attributes)
{
var attribute = CSAttribute.Parse(attributeNode);
fieldObject.AttributeList.Add(attribute);
}
}
returnList.Add(fieldObject);
}
return returnList;
}
public override IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode<PropertyDeclaration> ();
if (property == null || !property.NameToken.Contains(context.Location))
yield break;
if (!IsNotImplemented (context, property.Getter.Body) ||
!IsNotImplemented (context, property.Setter.Body)) {
yield break;
}
yield return new CodeAction(context.TranslateString("Implement property"), script => {
string backingStoreName = context.GetNameProposal (property.Name);
// create field
var backingStore = new FieldDeclaration ();
if (property.Modifiers.HasFlag (Modifiers.Static))
backingStore.Modifiers |= Modifiers.Static;
if (property.Setter.IsNull)
backingStore.Modifiers |= Modifiers.Readonly;
backingStore.ReturnType = property.ReturnType.Clone ();
var initializer = new VariableInitializer (backingStoreName);
backingStore.Variables.Add (initializer);
// create new property & implement the get/set bodies
var newProperty = (PropertyDeclaration)property.Clone ();
Expression id1;
if (backingStoreName == "value")
id1 = new ThisReferenceExpression().Member("value");
else
id1 = new IdentifierExpression (backingStoreName);
Expression id2 = id1.Clone();
newProperty.Getter.Body = new BlockStatement () {
new ReturnStatement (id1)
};
if (!property.Setter.IsNull) {
newProperty.Setter.Body = new BlockStatement () {
new AssignmentExpression (id2, AssignmentOperatorType.Assign, new IdentifierExpression ("value"))
};
}
script.Replace (property, newProperty);
script.InsertBefore (property, backingStore);
if (!property.Setter.IsNull)
script.Link (initializer, id1, id2);
else
script.Link (initializer, id1);
}, property.NameToken);
}
private OverloadsCollection(IEmitter emitter, FieldDeclaration fieldDeclaration)
{
this.Emitter = emitter;
this.Name = emitter.GetFieldName(fieldDeclaration);
this.JsName = this.Emitter.GetEntityName(fieldDeclaration, false, true);
this.Inherit = !fieldDeclaration.HasModifier(Modifiers.Static);
this.Static = fieldDeclaration.HasModifier(Modifiers.Static);
this.Member = this.FindMember(fieldDeclaration);
this.TypeDefinition = this.Member.DeclaringTypeDefinition;
this.Type = this.Member.DeclaringType;
this.InitMembers();
this.Emitter.OverloadsCache[fieldDeclaration.GetHashCode().ToString()] = this;
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var pexpr = context.GetNode<PrimitiveExpression>();
if (pexpr == null)
yield break;
var statement = context.GetNode<Statement>();
if (statement == null) {
yield break;
}
var resolveResult = context.Resolve(pexpr);
yield return new CodeAction(context.TranslateString("Create local constant"), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
name = service.CheckName(context, name, AffectedEntity.LocalConstant);
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new VariableDeclarationStatement() {
Type = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
script.InsertBefore(statement, decl);
var variableUsage = new IdentifierExpression(name);
script.Replace(pexpr, variableUsage);
script.Link(initializer.NameToken, variableUsage);
});
yield return new CodeAction(context.TranslateString("Create constant field"), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
name = service.CheckName(context, name, AffectedEntity.ConstantField);
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new FieldDeclaration() {
ReturnType = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
var variableUsage = new IdentifierExpression(name);
script.Replace(pexpr, variableUsage);
// script.Link(initializer.NameToken, variableUsage);
script.InsertWithCursor(context.TranslateString("Create constant"), Script.InsertPosition.Before, decl);
});
}
bool UsesAllTypeParameters(FieldDeclaration fieldDeclaration)
{
if (availableTypeParameters.Count == 0)
return true;
var fieldType = ctx.Resolve(fieldDeclaration.ReturnType).Type as ParameterizedType;
if (fieldType == null)
return false;
// Check that all current type parameters are used in the field type
var fieldTypeParameters = fieldType.TypeArguments;
foreach (var typeParameter in availableTypeParameters) {
if (!fieldTypeParameters.Contains(typeParameter))
return false;
}
return true;
}
static PropertyDeclaration GeneratePropertyDeclaration (RefactoringContext context, FieldDeclaration field, VariableInitializer initializer)
{
var mod = ICSharpCode.NRefactory.CSharp.Modifiers.Public;
if (field.HasModifier (ICSharpCode.NRefactory.CSharp.Modifiers.Static))
mod |= ICSharpCode.NRefactory.CSharp.Modifiers.Static;
return new PropertyDeclaration () {
Modifiers = mod,
Name = context.GetNameProposal (initializer.Name, false),
ReturnType = field.ReturnType.Clone (),
Getter = new Accessor () {
Body = new BlockStatement () {
new ReturnStatement (new IdentifierExpression (initializer.Name))
}
}
};
}
public override void VisitFieldDeclaration (FieldDeclaration fieldDeclaration)
{
base.VisitFieldDeclaration (fieldDeclaration);
var defaultValueExpr = GetDefaultValueExpression (fieldDeclaration.ReturnType);
if (defaultValueExpr == null)
return;
foreach (var variable1 in fieldDeclaration.Variables) {
var variable = variable1;
if (!defaultValueExpr.Match (variable.Initializer).Success)
continue;
AddIssue (variable, ctx.TranslateString ("Remove redundant field initializer"),
script => script.Replace (variable, new VariableInitializer (variable.Name)));
}
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var expr = context.GetNode(n => n is IdentifierExpression || n is MemberReferenceExpression) as Expression;
if (expr == null)
yield break;
if (expr is MemberReferenceExpression && !(((MemberReferenceExpression)expr).Target is ThisReferenceExpression))
yield break;
var propertyName = CreatePropertyAction.GetPropertyName(expr);
if (propertyName == null)
yield break;
if (IsInvocationTarget(expr))
yield break;
var statement = expr.GetParent<Statement>();
if (statement == null)
yield break;
if (!(context.Resolve(expr).IsError))
yield break;
var guessedType = CreateFieldAction.GuessAstType(context, expr);
if (guessedType == null)
yield break;
var state = context.GetResolverStateBefore(expr);
if (state.CurrentMember == null || state.CurrentTypeDefinition == null)
yield break;
bool isStatic = state.CurrentMember.IsStatic | state.CurrentTypeDefinition.IsStatic;
// var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
// if (service != null && !service.IsValidName(identifier.Identifier, AffectedEntity.Field, Modifiers.Private, isStatic)) {
// yield break;
// }
yield return new CodeAction(context.TranslateString("Create field"), script => {
var decl = new FieldDeclaration() {
ReturnType = guessedType,
Variables = { new VariableInitializer(propertyName) }
};
if (isStatic)
decl.Modifiers |= Modifiers.Static;
script.InsertWithCursor(context.TranslateString("Create field"), Script.InsertPosition.Before, decl);
});
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
//TODO: implement variable assignment & ctor param
var varInit = context.GetNode<VariableInitializer>();
if (varInit != null) {
AstType type = varInit.GetPrevNode() as AstType;
if (type == null) yield break;
if (varInit.Parent is FieldDeclaration) yield break;
if (CannotExtractField(varInit)) yield break;
yield return new CodeAction("Extract field", s=>{
var name = varInit.Name;
FieldDeclaration field = new FieldDeclaration(){
ReturnType = type.Clone(),
Variables = { new VariableInitializer(name) }
};
AstNode nodeToRemove = RemoveDeclaration(varInit) ? varInit.Parent : type;
s.Remove(nodeToRemove, true);
s.InsertWithCursor(context.TranslateString("Extract field"),Script.InsertPosition.Before,field);
s.FormatText(varInit.Parent);
});
}
var idntf = context.GetNode<Identifier>();
if (idntf == null) yield break;
var paramDec = idntf.Parent as ParameterDeclaration;
if (paramDec != null) {
var ctor = paramDec.Parent as ConstructorDeclaration;
if (ctor == null) yield break;
MemberReferenceExpression thisField = new MemberReferenceExpression(new ThisReferenceExpression(), idntf.Name, new AstType[]{});
var assign = new AssignmentExpression(thisField, AssignmentOperatorType.Assign, new IdentifierExpression(idntf.Name));
var statement = new ExpressionStatement(assign);
var type = (idntf.GetPrevNode() as AstType).Clone();
FieldDeclaration field = new FieldDeclaration(){
ReturnType = type.Clone(),
Variables = { new VariableInitializer(idntf.Name) }
};
yield return new CodeAction("Extract field", s=>{
s.InsertWithCursor(context.TranslateString("Extract field"),Script.InsertPosition.Before,field);
s.AddTo(ctor.Body, statement);
});
}
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode<PropertyDeclaration>();
if (!(property != null &&
!property.Getter.IsNull && !property.Setter.IsNull && // automatic properties always need getter & setter
property.Getter.Body.IsNull &&
property.Setter.Body.IsNull)) {
yield break;
}
yield return new CodeAction(context.TranslateString("Create backing store"), script => {
string backingStoreName = context.GetNameProposal (property.Name);
// create field
var backingStore = new FieldDeclaration ();
if (property.Modifiers.HasFlag (Modifiers.Static))
backingStore.Modifiers |= Modifiers.Static;
backingStore.ReturnType = property.ReturnType.Clone ();
var initializer = new VariableInitializer (backingStoreName);
backingStore.Variables.Add (initializer);
// create new property & implement the get/set bodies
var newProperty = (PropertyDeclaration)property.Clone ();
Expression id1;
if (backingStoreName == "value")
id1 = new ThisReferenceExpression().Member("value");
else
id1 = new IdentifierExpression (backingStoreName);
Expression id2 = id1.Clone();
newProperty.Getter.Body = new BlockStatement () {
new ReturnStatement (id1)
};
newProperty.Setter.Body = new BlockStatement () {
new AssignmentExpression (id2, AssignmentOperatorType.Assign, new IdentifierExpression ("value"))
};
script.Replace (property, newProperty);
script.InsertBefore (property, backingStore);
script.Link (initializer, id1, id2);
});
}
public override void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
{
if (fieldDeclaration.Modifiers.HasFlag(Modifiers.Static))
return;
foreach (var attributeSection in fieldDeclaration.Attributes) {
int attributeCount = attributeSection.Attributes.Count;
foreach (var attribute in attributeSection.Attributes) {
var resolvedAttribute = ctx.Resolve(attribute.Type) as TypeResolveResult;
if (resolvedAttribute == null)
continue;
if (threadStaticDefinition.Equals(resolvedAttribute.Type.GetDefinition())) {
string title = ctx.TranslateString("ThreadStatic does nothing on instance fields");
if (attributeCount == 1)
AddIssue(attributeSection, title, GetActions(attribute, attributeSection, fieldDeclaration));
else
AddIssue(attribute, title, GetActions(attribute, attributeSection, fieldDeclaration));
}
}
}
}
static PropertyDeclaration GeneratePropertyDeclaration (RefactoringContext context, FieldDeclaration field, string fieldName)
{
var mod = ICSharpCode.NRefactory.CSharp.Modifiers.Public;
if (field.HasModifier (ICSharpCode.NRefactory.CSharp.Modifiers.Static))
mod |= ICSharpCode.NRefactory.CSharp.Modifiers.Static;
return new PropertyDeclaration () {
Modifiers = mod,
Name = context.GetNameProposal (fieldName, false),
ReturnType = field.ReturnType.Clone (),
Getter = new Accessor () {
Body = new BlockStatement () {
new ReturnStatement (new IdentifierExpression (fieldName))
}
},
Setter = new Accessor () {
Body = new BlockStatement () {
new ExpressionStatement (new AssignmentExpression (new IdentifierExpression (fieldName), new IdentifierExpression ("value")))
}
}
};
}
public void Run(AstNode compilationUnit)
{
ConstructorDeclaration ctorDecl = null;
foreach (var node in compilationUnit.Children)
{
ConstructorDeclaration ctor = node as ConstructorDeclaration;
if (ctor != null)
{
if (ctor.Annotation <MethodDef>() == ctorDef)
{
ctorDecl = ctor;
}
else
{
// remove other ctors
ctor.Remove();
}
}
// Remove any fields without initializers
FieldDeclaration fd = node as FieldDeclaration;
if (fd != null && fd.Variables.All(v => v.Initializer.IsNull))
{
fd.Remove();
}
}
if (ctorDecl.Initializer.ConstructorInitializerType == ConstructorInitializerType.This)
{
// remove all fields
foreach (var node in compilationUnit.Children)
{
if (node is FieldDeclaration)
{
node.Remove();
}
}
}
}
public void InheritedInnerType()
{
string program = TestUtil.PackageMemberParse(@"public class BaseClass {
public interface BaseInnerType
{
}
}
public class InheritedClass extends BaseClass{
BaseInnerType inner;
}" );
CompilationUnit cu = TestUtil.ParseProgram(program);
TypesVisitor typesVisitor = new TypesVisitor();
typesVisitor.CodeBase = this.CodeBase;
typesVisitor.VisitCompilationUnit(cu, null);
TypeDeclaration ty = (TypeDeclaration)CodeBase.Types["Test.InheritedClass"];
FieldDeclaration fd = (FieldDeclaration)ty.Children[0];
string type = GetFullName(fd.TypeReference);
Assert.AreEqual("Test.BaseClass$BaseInnerType", type);
}
public override void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
{
base.VisitFieldDeclaration(fieldDeclaration);
var defaultValueExpr = GetDefaultValueExpression(fieldDeclaration.ReturnType);
if (defaultValueExpr == null)
{
return;
}
foreach (var variable1 in fieldDeclaration.Variables)
{
var variable = variable1;
if (!defaultValueExpr.Match(variable.Initializer).Success)
{
continue;
}
AddIssue(variable.Initializer, ctx.TranslateString("Remove redundant field initializer"),
script => script.Replace(variable, new VariableInitializer(variable.Name)));
}
}
public override object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
{
foreach (INode node in fieldDeclaration.Children)
{
if (node is VariableInitializer && node.NextSibling != null && node.NextSibling.Role == FieldDeclaration.Roles.Comma)
{
VariableInitializer initializer = node as VariableInitializer;
CSharpTokenNode commaToken = (CSharpTokenNode)node.NextSibling;
int offset = this.data.Document.LocationToOffset(initializer.NameIdentifier.StartLocation.Line, initializer.NameIdentifier.StartLocation.Column);
int commaOffset = this.data.Document.LocationToOffset(commaToken.StartLocation.Line, commaToken.StartLocation.Column);
ForceSpace(offset, commaOffset, policy.SpacesAfterComma);
//Console.WriteLine (initializer.Name +"/" + initializer.NameIdentifier + "/" + commaToken);
if (node.NextSibling.NextSibling is VariableInitializer)
{
DomLocation location = ((VariableInitializer)node.NextSibling.NextSibling).NameIdentifier.StartLocation;
int nextOffset = this.data.Document.LocationToOffset(location.Line, location.Column);
ForceSpace(commaOffset, nextOffset, policy.SpacesAfterComma);
}
}
}
return(base.VisitFieldDeclaration(fieldDeclaration, data));
}
public void AddPublicVariable_VariableTypeIsCustomType_CodeForFieldAddedAtEndOfClass()
{
CreateClass("MyClass");
CreateCodeGenerator();
var classRegion = new DomRegion(1, 2, 3, 4);
helper.SetClassRegion(classRegion);
string fileName = @"d:\projects\myproject\MyClass.cs";
SetClassFileName(fileName);
SetDocumentFileName(fileName);
AddFieldToClassForReparse("MyClass.MyVariable");
AddPublicVariable("MyVar", "MyType");
FieldDeclaration field = fakeCodeGenerator.NodePassedToInsertCodeAtEnd as FieldDeclaration;
Assert.AreEqual(classRegion, fakeCodeGenerator.RegionPassedToInsertCodeAtEnd);
Assert.AreEqual(document, fakeCodeGenerator.DocumentPassedToInsertCodeAtEnd);
Assert.AreEqual(Modifiers.Public, field.Modifier);
Assert.AreEqual("MyType", field.TypeReference.Type);
Assert.AreEqual("MyVar", field.Fields[0].Name);
}
public void HasAccessibility()
{
string program = TestUtil.TypeMemberParse("private static ConstantSize DIALOG_MARGIN_X = Sizes.DLUX7;");
CompilationUnit cu = TestUtil.ParseProgram(program);
VisitCompilationUnit(cu, null);
NamespaceDeclaration ns = (NamespaceDeclaration)cu.Children[0];
TypeDeclaration ty = (TypeDeclaration)ns.Children[0];
FieldDeclaration md = (FieldDeclaration)ty.Children[0];
Modifiers expectedModifier = Modifiers.Private | Modifiers.Static;
Assert.IsNotNull(md);
Assert.AreEqual(expectedModifier, md.Modifier);
program = TestUtil.TypeMemberParse("public int ID;");
cu = TestUtil.ParseProgram(program);
VisitCompilationUnit(cu, null);
string expected = TestUtil.CSharpTypeMemberParse("public int ID;");
TestUtil.CodeEqual(expected, TestUtil.GenerateCode(cu));
}
private MatchContext MatchFieldDeclaration(FieldDeclaration fieldDeclaration, MatchContext context)
{
if (LocalVariable || fieldDeclaration.Variables.Count != 1)
{
return(context.Fail());
}
MatchContext newContext = Modifiers.MatchSubset(fieldDeclaration.Modifiers, context);
if (!newContext.Success)
{
return(newContext);
}
newContext = Type.MatchUst(fieldDeclaration.Type, newContext);
if (!newContext.Success)
{
return(newContext);
}
newContext = EnumerateVarsOrFields(fieldDeclaration.Variables, newContext);
return(newContext);
}
public void AddProperties()
{
NamespaceDeclaration nsdecl = new NamespaceDeclaration("Test");
ClassDeclaration cdecl = nsdecl.AddClass("Customer");
FieldDeclaration lastName = new FieldDeclaration("_lastName", "System.String");
PropertyDeclaration propdecl = new PropertyDeclaration("LastName", lastName, typeof(string));
cdecl.AddProperty(propdecl);
PropertyDeclaration firstName = cdecl.AddProperty("FirstName", "_firstName", typeof(string));
PropertyDeclaration duplicateFirstName = cdecl.AddProperty("FirstName", "_firstName", typeof(string));
Assert.AreEqual(firstName, duplicateFirstName);
cdecl.AddProperty("DateOfBirth", "_dateOfBirth", typeof(DateTime), true);
cdecl.AddProperty("Age", "_age", new CodeDomTypeReference(typeof(int)));
cdecl.AddProperty("Items", "_items", "System.Collections.Generic.List", "System.String");
using (DomTester dom = new DomTester(nsdecl))
{
Assert.IsTrue(dom.ContainsType("Test.Customer"));
Assert.IsTrue(dom.ContainsProperty("Test.Customer", "FirstName"));
Assert.IsTrue(dom.ContainsProperty("Test.Customer", "LastName"));
Assert.IsTrue(dom.ContainsProperty("Test.Customer", "DateOfBirth"));
Assert.IsTrue(dom.ContainsProperty("Test.Customer", "Age"));
Assert.IsTrue(dom.ContainsProperty("Test.Customer", "Items"));
}
new CodeBuilder().GenerateCode(Console.Out, nsdecl);
}
public void Run(AstNode node)
{
FieldDeclaration field = node as FieldDeclaration;
if (field != null)
{
bool isCompilerGenerated = false;
foreach (AttributeSection section in field.Attributes)
{
foreach (ICSharpCode.NRefactory.CSharp.Attribute attr in section.Attributes)
{
if (attr.GetText() == "CompilerGenerated")
{
isCompilerGenerated = true;
break;
}
}
}
if (isCompilerGenerated)
{
field.Remove();
}
}
}
bool IsField(string identifier)
{
if (currentTypeDeclaration == null) // e.g. in unit tests
{
return(false);
}
foreach (INode node in currentTypeDeclaration.Children)
{
if (node is FieldDeclaration)
{
FieldDeclaration fd = (FieldDeclaration)node;
if (fd.GetVariableDeclaration(identifier) != null)
{
return(true);
}
}
}
//field detection for fields\props inherited from base classes
if (currentTypeDeclaration.BaseTypes.Count > 0)
{
return(IsField(currentTypeDeclaration.BaseTypes[0].ToString(), identifier));
}
return(false);
}
IEnumerable<CodeAction> GetActions(Attribute attribute, AttributeSection attributeSection, FieldDeclaration fieldDeclaration)
{
string removeAttributeMessage = ctx.TranslateString("Remove attribute");
yield return new CodeAction(removeAttributeMessage, script => {
if (attributeSection.Attributes.Count > 1) {
var newSection = new AttributeSection();
newSection.AttributeTarget = attributeSection.AttributeTarget;
foreach (var attr in attributeSection.Attributes) {
if (attr != attribute)
newSection.Attributes.Add((Attribute)attr.Clone());
}
script.Replace(attributeSection, newSection);
} else {
script.Remove(attributeSection);
}
});
var makeStaticMessage = ctx.TranslateString("Make the field static");
yield return new CodeAction(makeStaticMessage, script => {
var newDeclaration = (FieldDeclaration)fieldDeclaration.Clone();
newDeclaration.Modifiers |= Modifiers.Static;
script.Replace(fieldDeclaration, newDeclaration);
});
}
public override object Visit(FieldDeclaration fieldDeclaration, object data)
{
for (int i = 0; i < fieldDeclaration.Fields.Count; ++i)
{
VariableDeclaration field = (VariableDeclaration)fieldDeclaration.Fields[i];
if ((fieldDeclaration.Modifier & Modifier.WithEvents) != 0)
{
//this.withEventsFields.Add(field);
}
string typeString = fieldDeclaration.GetTypeForField(i).Type;
CodeMemberField memberField = new CodeMemberField(new CodeTypeReference(ConvType(typeString)), field.Name);
memberField.Attributes = ConvMemberAttributes(fieldDeclaration.Modifier);
if (!field.Initializer.IsNull)
{
memberField.InitExpression = (CodeExpression)field.Initializer.AcceptVisitor(this, data);
}
typeDeclarations.Peek().Members.Add(memberField);
}
return(null);
}
public override void Translate(EventDeclaration model, TranslationContext context)
{
if (model == null)
{
return;
}
string fieldAddScript = null;
string fieldRemScript = null;
if (model.IsField)
{
// add a backing event list
var fieldName = "$" + model.Definition.Name;
var backingField = new FieldDeclaration
{
Container = model.Container,
OriginatingNode = model.OriginatingNode,
OriginatingTree = model.OriginatingTree,
Definition = new FieldDefinition
{
Name = fieldName,
ContainingType = model.Definition.ContainingType,
Type = new ClassDefinition()
{
Kind = DefinitionKind.Type,
Name = "Event",
Namespace = "Blade",
}
},
Initializer = new LiteralExpression
{
Type = LiteralType.None,
Text = "new Blade.Event()"
}
};
// use same modifier as property, but force private
backingField.Definition.Modifiers.Apply(model.Definition.Modifiers);
backingField.Definition.Modifiers.Access = Accessibility.Private;
context.WriteModel(backingField);
// manually create get/set body
var fieldPrefix = model.IsStatic ? model.Container.Name : "this";
var fieldAccess = fieldPrefix + "." + fieldName;
fieldAddScript = fieldAccess + ".add(func, ctx);";
fieldRemScript = fieldAccess + ".rem(func);";
// add a method to invoke the event
context.WriteDeclaration(model);
context.WriteLine(" = function() {");
context.Indent();
context.WriteLine(fieldAccess + ".pub.apply(" + fieldAccess + ", arguments);");
context.Unindent();
context.WriteLine("}");
}
// write the add accessor
context.WriteDeclaration(model, postfix: "$add");
context.WriteLine(" = function(func, ctx) {");
context.Indent();
if (model.IsField)
{
context.WriteLine(fieldAddScript);
}
else
{
context.WriteModelBody(model.AddAccessor);
}
context.Unindent();
context.WriteLine("};");
// write the remove accessor
context.WriteDeclaration(model, postfix: "$rem");
context.WriteLine(" = function(func) {");
context.Indent();
if (model.IsField)
{
context.WriteLine(fieldRemScript);
}
else
{
context.WriteModelBody(model.RemoveAccessor);
}
context.Unindent();
context.WriteLine("};");
}
public virtual T Visit(FieldDeclaration node) => Visit(node as VariableDeclarationNode);
public override void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
{
bool isStatic = this.CurrentType.ClassType == ClassType.Enum ||
fieldDeclaration.HasModifier(Modifiers.Static) ||
fieldDeclaration.HasModifier(Modifiers.Const);
foreach (var item in fieldDeclaration.Variables)
{
var rr = this.Resolver.ResolveNode(item, null) as MemberResolveResult;
if (fieldDeclaration.HasModifier(Modifiers.Const) && rr != null && rr.Member.Attributes.Any(a => a.AttributeType.FullName == Bridge.Translator.Translator.Bridge_ASSEMBLY + ".InlineConstAttribute"))
{
continue;
}
Expression initializer = item.Initializer;
if (initializer.IsNull)
{
if (this.CurrentType.ClassType == ClassType.Enum)
{
throw (EmitterException)this.CreateException(fieldDeclaration, "Enum items must be explicitly numbered");
}
initializer = this.GetDefaultFieldInitializer(fieldDeclaration.ReturnType);
}
this.CurrentType.FieldsDeclarations.Add(item.Name, fieldDeclaration);
string prefix = SharpSixRewriter.AutoInitFieldPrefix;
bool autoInitializer = item.Name.StartsWith(prefix);
string name = autoInitializer ? item.Name.Substring(prefix.Length) : item.Name;
if (isStatic)
{
var collection = this.CurrentType.StaticConfig.Fields;
if (autoInitializer)
{
collection = this.CurrentType.StaticConfig.AutoPropertyInitializers;
var prop = this.CurrentType.StaticConfig.Properties.FirstOrDefault(p => p.Name == name);
if (prop == null)
{
prop = this.CurrentType.StaticConfig.Fields.FirstOrDefault(p => p.Name == name);
}
if (prop != null)
{
prop.Initializer = initializer;
}
}
collection.Add(new TypeConfigItem
{
Name = name,
Entity = fieldDeclaration,
IsConst = fieldDeclaration.HasModifier(Modifiers.Const),
VarInitializer = item,
Initializer = initializer
});
}
else
{
var collection = this.CurrentType.InstanceConfig.Fields;
if (autoInitializer)
{
collection = this.CurrentType.InstanceConfig.AutoPropertyInitializers;
var prop = this.CurrentType.InstanceConfig.Properties.FirstOrDefault(p => p.Name == name);
if (prop == null)
{
prop = this.CurrentType.InstanceConfig.Fields.FirstOrDefault(p => p.Name == name);
}
if (prop != null)
{
prop.Initializer = initializer;
}
}
collection.Add(new TypeConfigItem
{
Name = name,
Entity = fieldDeclaration,
VarInitializer = item,
Initializer = initializer
});
}
if (OverloadsCollection.NeedCreateAlias(rr))
{
var config = isStatic
? CurrentType.StaticConfig
: CurrentType.InstanceConfig;
config.Alias.Add(new TypeConfigItem {
Entity = fieldDeclaration, VarInitializer = item
});
}
}
}
public override void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
{
VisitXmlChildren(fieldDeclaration);
}
private TypeDeclaration GetTypeDeclaration(ClassFile clazz)
{
TypeDeclaration typeDeclaration = new TypeDeclaration(Modifiers.None, null);
if (clazz.IsInterface)
{
typeDeclaration.Type = ClassType.Interface;
}
else
{
typeDeclaration.Modifier = Modifiers.Abstract;
}
typeDeclaration.Name = clazz.Name;
if (clazz.Name.IndexOf("$") == -1)
{
typeDeclaration.Name = GetTypeName(clazz.Name);
}
foreach (ClassFile.Method method in clazz.Methods)
{
if (!(method.IsPublic || method.IsProtected))
{
continue;
}
ParametrizedNode methodDeclaration;
if (method.Name == "<init>")
{
methodDeclaration = new ConstructorDeclaration(typeDeclaration.Name, Modifiers.Public, null, null);
}
else
{
TypeReference returnType = sigParser.GetReturnType(method.Signature);
methodDeclaration = new MethodDeclaration(method.Name, Modifiers.None, returnType, null, null);
if (method.IsAbstract)
{
methodDeclaration.Modifier |= Modifiers.Abstract;
}
methodDeclaration.Modifier |= Modifiers.Public;
}
methodDeclaration.Parent = typeDeclaration;
if (IncludeParamters)
{
TypeReference[] arguments = sigParser.GetArgumentTypes(method.Signature);
int i = 1;
foreach (TypeReference typeRef in arguments)
{
ParameterDeclarationExpression param = new ParameterDeclarationExpression(typeRef, "parameter" + i++.ToString());
methodDeclaration.Parameters.Add(param);
}
}
typeDeclaration.Children.Add(methodDeclaration);
}
foreach (ClassFile.Field field in clazz.Fields)
{
if (!field.IsPublic)
{
continue;
}
TypeReference type = sigParser.GetFieldType(field.Signature);
FieldDeclaration fieldDeclaration = new FieldDeclaration(null, type, Modifiers.None);
fieldDeclaration.Fields.Add(new VariableDeclaration(field.Name));
fieldDeclaration.Parent = typeDeclaration;
typeDeclaration.Children.Add(fieldDeclaration);
}
if (clazz.Name != "java.lang.Object" && clazz.SuperClass != null && clazz.SuperClass != "java.lang.Object")
{
TypeReference baseType = new TypeReference(clazz.SuperClass.Replace("$", "."));
baseType.Kind = TypeReferenceKind.Extends;
typeDeclaration.BaseTypes.Add(baseType);
}
foreach (ClassFile.ConstantPoolItemClass interfaceType in clazz.Interfaces)
{
TypeReference interf = new TypeReference(interfaceType.Name.Replace("$", "."));
interf.Kind = TypeReferenceKind.Implements;
typeDeclaration.BaseTypes.Add(interf);
}
return(typeDeclaration);
}
private void AddArrayField(ClassDeclaration c, FieldInfo f)
{
// create a collection
ClassDeclaration col = c.AddClass(conformer.ToSingular(f.Name) + "Collection");
col.Parent = new TypeTypeDeclaration(typeof(System.Collections.CollectionBase));
// add serializable attribute
col.CustomAttributes.Add(typeof(SerializableAttribute));
// default constructor
col.AddConstructor();
// default indexer
IndexerDeclaration index = col.AddIndexer(
typeof(Object)
);
ParameterDeclaration pindex = index.Signature.Parameters.Add(typeof(int), "index", false);
// getter
index.Get.Return(
Expr.This.Prop("List").Item(Expr.Arg(pindex))
);
index.Set.AddAssign(
Expr.This.Prop("List").Item(Expr.Arg(pindex)),
Expr.Value
);
// add object method
MethodDeclaration addObject = col.AddMethod("Add");
ParameterDeclaration paraObject = addObject.Signature.Parameters.Add(new TypeTypeDeclaration(typeof(Object)), "o", true);
addObject.Body.Add(
Expr.This.Prop("List").Method("Add").Invoke(paraObject)
);
// if typed array add methods for type
if (f.FieldType.GetElementType() != typeof(Object))
{
AddCollectionMethods(
col,
MapType(f.FieldType.GetElementType()),
this.conformer.ToCapitalized(f.FieldType.GetElementType().Name),
"o"
);
}
foreach (XmlElementAttribute ea in f.GetCustomAttributes(typeof(XmlElementAttribute), true))
{
string name = this.conformer.ToCapitalized(ea.ElementName);
string pname = this.conformer.ToCamel(name);
ITypeDeclaration mappedType = null;
if (ea.Type != null)
{
mappedType = MapType(ea.Type);
}
if (mappedType == null || mappedType == f.FieldType.GetElementType())
{
continue;
}
AddCollectionMethods(col, mappedType, name, pname);
}
// add field
FieldDeclaration fd = c.AddField(col, f.Name);
fd.InitExpression = Expr.New(col);
PropertyDeclaration p = c.AddProperty(fd, f.Name, true, true, false);
// setting attributes
// attach xml text
if (TypeHelper.HasCustomAttribute(f, typeof(XmlTextAttribute)))
{
AttributeDeclaration attr = p.CustomAttributes.Add(typeof(XmlTextAttribute));
attr.Arguments.Add("Type", Expr.TypeOf(typeof(string)));
// adding to string to collection
MethodDeclaration tostring = col.AddMethod("ToString");
tostring.Signature.ReturnType = new TypeTypeDeclaration(typeof(String));
tostring.Attributes = MemberAttributes.Public | MemberAttributes.Override;
VariableDeclarationStatement sw = Stm.Var(typeof(StringWriter), "sw");
sw.InitExpression = Expr.New(typeof(StringWriter));
tostring.Body.Add(sw);
ForEachStatement fe = Stm.ForEach(
typeof(string), "s", Expr.This.Prop("List"), false);
fe.Body.Add(
Expr.Var(sw).Method("Write").Invoke(fe.Local)
);
tostring.Body.Add(fe);
tostring.Body.Return(Expr.Var(sw).Method("ToString").Invoke());
}
else if (TypeHelper.HasCustomAttribute(f, typeof(XmlArrayItemAttribute)))
{
// add xml array attribute
AttributeDeclaration attr = p.CustomAttributes.Add(typeof(XmlArrayAttribute));
attr.Arguments.Add("ElementName", Expr.Prim(f.Name));
// add array item attribute
XmlArrayItemAttribute arrayItem =
(XmlArrayItemAttribute)TypeHelper.GetFirstCustomAttribute(f, typeof(XmlArrayItemAttribute));
attr = p.CustomAttributes.Add(typeof(XmlArrayItemAttribute));
attr.Arguments.Add("ElementName", Expr.Prim(arrayItem.ElementName));
//MMI:attr.Arguments.Add("Type",Expr.Prim(MapType(f.FieldType.GetElementType()).Name));
attr.Arguments.Add("Type", Expr.TypeOf(MapType(f.FieldType.GetElementType())));
if (arrayItem.Type != null)
{
attr.Arguments.Add("DataType", Expr.Prim(arrayItem.DataType));
}
attr.Arguments.Add("IsNullable", Expr.Prim(arrayItem.IsNullable));
if (this.Config.KeepNamespaces)
{
attr.Arguments.Add("Namespace", Expr.Prim(arrayItem.Namespace));
}
}
else
{
AttachXmlElementAttributes(p, f);
}
}
/// <summary>
/// Fix type names and remove unused methods.
/// </summary>
void FixTypeNames(object o, ICSharpCode.SharpDevelop.Dom.ICompilationUnit domCu, ref bool foundInitMethod)
{
if (domCu == null)
{
return;
}
CompilationUnit cu = o as CompilationUnit;
if (cu != null)
{
foreach (object c in cu.Children)
{
FixTypeNames(c, domCu, ref foundInitMethod);
}
return;
}
NamespaceDeclaration namespaceDecl = o as NamespaceDeclaration;
if (namespaceDecl != null)
{
foreach (object c in namespaceDecl.Children)
{
FixTypeNames(c, domCu, ref foundInitMethod);
}
return;
}
TypeDeclaration typeDecl = o as TypeDeclaration;
if (typeDecl != null)
{
for (int i = 0; i < typeDecl.BaseTypes.Count; i++)
{
typeDecl.BaseTypes[i] = FixTypeReference(typeDecl.BaseTypes[i], typeDecl.StartLocation, domCu, ReturnTypeOptions.BaseTypeReference);
}
for (int i = 0; i < typeDecl.Children.Count; i++)
{
object child = typeDecl.Children[i];
MethodDeclaration method = child as MethodDeclaration;
if (method != null)
{
// remove all methods except InitializeComponents
if ((method.Name == "InitializeComponents" || method.Name == "InitializeComponent") && method.Parameters.Count == 0)
{
method.Name = "InitializeComponent";
if (foundInitMethod)
{
throw new FormsDesignerLoadException("There are multiple InitializeComponent methods in the class. Designer cannot be loaded.");
}
foundInitMethod = true;
}
else
{
typeDecl.Children.RemoveAt(i--);
}
}
else if (child is TypeDeclaration || child is FieldDeclaration)
{
FixTypeNames(child, domCu, ref foundInitMethod);
}
else
{
// child is property, event etc.
typeDecl.Children.RemoveAt(i--);
}
}
return;
}
FieldDeclaration fieldDecl = o as FieldDeclaration;
if (fieldDecl != null)
{
fieldDecl.TypeReference = FixTypeReference(fieldDecl.TypeReference, fieldDecl.StartLocation, domCu, ReturnTypeOptions.None);
foreach (VariableDeclaration var in fieldDecl.Fields)
{
if (var != null)
{
var.TypeReference = FixTypeReference(var.TypeReference, fieldDecl.StartLocation, domCu, ReturnTypeOptions.None);
}
}
}
}
static PropertyDeclaration GeneratePropertyDeclaration(RefactoringContext context, FieldDeclaration field, VariableInitializer initializer)
{
var mod = ICSharpCode.NRefactory.Cpp.Modifiers.Public;
if (field.HasModifier(ICSharpCode.NRefactory.Cpp.Modifiers.Static))
{
mod |= ICSharpCode.NRefactory.Cpp.Modifiers.Static;
}
return(new PropertyDeclaration()
{
Modifiers = mod,
Name = context.GetNameProposal(initializer.Name, false),
ReturnType = field.ReturnType.Clone(),
Getter = new Accessor()
{
Body = new BlockStatement()
{
new ReturnStatement(new IdentifierExpression(initializer.Name))
}
}
});
}
public void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
{
StartNode(fieldDeclaration);
WriteAttributes(fieldDeclaration.Attributes);
WriteModifiers(fieldDeclaration.ModifierTokens);
fieldDeclaration.ReturnType.AcceptVisitor(this);
Space();
WriteCommaSeparatedList(fieldDeclaration.Variables);
Semicolon();
EndNode(fieldDeclaration);
}
public override IEnumerable <MonoDevelop.CodeActions.CodeAction> GetActions(MonoDevelop.Ide.Gui.Document document, object refactoringContext, TextLocation loc, CancellationToken cancellationToken)
{
MDRefactoringContext context = (MDRefactoringContext)refactoringContext;
if (context.IsInvalid)
{
yield break;
}
VariableInitializer currentVariable = context.GetNode <VariableInitializer>();
if (currentVariable == null)
{
yield break;
}
FieldDeclaration currentField = currentVariable.Parent as FieldDeclaration;
if (currentField == null)
{
yield break;
}
if (!currentField.Modifiers.HasFlag(Modifiers.Const))
{
yield break;
}
PrimitiveType baseType = TypeToIntegerPrimitive(context, currentField.ReturnType);
if (baseType == null)
{
//Can't make enums of these types
yield break;
}
TypeDeclaration containerType = currentVariable.GetParent <TypeDeclaration>();
//Get all the fields/variables that the enum can possibly cover
//Don't check the name just yet. That'll come later.
var constFields = containerType.Members.OfType <FieldDeclaration>()
.Where(field => field.GetParent <TypeDeclaration>() == containerType && field.HasModifier(Modifiers.Const)).ToList();
var constVariables = constFields.SelectMany(field => field.Variables).ToList();
//Now, it's time to check the name of the selected variable
//We'll use this to search for prefixes later
var names = constVariables.Select(variable => variable.Name).ToList();
string currentName = currentVariable.Name;
//Now, find the common name prefixes
//If the variable is called 'A_B_C_D', then 'A', 'A_B' and 'A_B_C' are
//the potentially available prefixes.
//Note that the common prefixes are the ones that more than one variable
//has.
//Each prefix has an associated action.
foreach (var prefix in GetCommonPrefixes(currentName, names))
{
string title = string.Format(GettextCatalog.GetString("Create enum '{0}'"), prefix);
yield return(new DefaultCodeAction(title, (ctx, script) => {
PrepareToRunAction(prefix, baseType, containerType, constVariables, cancellationToken, ctx, script);
}));
}
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var expr = GetCreatePropertyOrFieldNode(context);
if (expr == null)
{
yield break;
}
if (expr is MemberReferenceExpression && !(((MemberReferenceExpression)expr).Target is ThisReferenceExpression))
{
yield break;
}
var propertyName = CreatePropertyAction.GetPropertyName(expr);
if (propertyName == null)
{
yield break;
}
if (IsInvocationTarget(expr))
{
yield break;
}
var statement = expr.GetParent <Statement>();
if (statement == null)
{
yield break;
}
if (!(context.Resolve(expr).IsError))
{
yield break;
}
var guessedType = CreateFieldAction.GuessAstType(context, expr);
if (guessedType == null)
{
yield break;
}
var state = context.GetResolverStateBefore(expr);
if (state.CurrentMember == null || state.CurrentTypeDefinition == null)
{
yield break;
}
bool isStatic = !(expr is NamedExpression) && (state.CurrentMember.IsStatic | state.CurrentTypeDefinition.IsStatic);
// var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
// if (service != null && !service.IsValidName(identifier.Identifier, AffectedEntity.Field, Modifiers.Private, isStatic)) {
// yield break;
// }
yield return(new CodeAction(context.TranslateString("Create field"), script => {
var decl = new FieldDeclaration()
{
ReturnType = guessedType,
Variables = { new VariableInitializer(propertyName) }
};
if (isStatic)
{
decl.Modifiers |= Modifiers.Static;
}
script.InsertWithCursor(context.TranslateString("Create field"), Script.InsertPosition.Before, decl);
}));
}
static PropertyDeclaration GeneratePropertyDeclaration(RefactoringContext context, FieldDeclaration field, string fieldName)
{
var mod = ICSharpCode.NRefactory.CSharp.Modifiers.Public;
if (field.HasModifier(ICSharpCode.NRefactory.CSharp.Modifiers.Static))
{
mod |= ICSharpCode.NRefactory.CSharp.Modifiers.Static;
}
return(new PropertyDeclaration()
{
Modifiers = mod,
Name = context.GetNameProposal(fieldName, false),
ReturnType = field.ReturnType.Clone(),
Getter = new Accessor()
{
Body = new BlockStatement()
{
new ReturnStatement(new IdentifierExpression(fieldName))
}
},
Setter = new Accessor()
{
Body = new BlockStatement()
{
new ExpressionStatement(new AssignmentExpression(new IdentifierExpression(fieldName), new IdentifierExpression("value")))
}
}
});
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var pexpr = context.GetNode <PrimitiveExpression>();
if (pexpr == null)
{
yield break;
}
var statement = context.GetNode <Statement>();
if (statement == null)
{
yield break;
}
var resolveResult = context.Resolve(pexpr);
yield return(new CodeAction(context.TranslateString("Create local constant"), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
{
name = service.CheckName(context, name, AffectedEntity.LocalConstant);
}
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new VariableDeclarationStatement()
{
Type = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
script.InsertBefore(statement, decl);
var variableUsage = new IdentifierExpression(name);
script.Replace(pexpr, variableUsage);
script.Link(initializer.NameToken, variableUsage);
}));
yield return(new CodeAction(context.TranslateString("Create constant field"), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
{
name = service.CheckName(context, name, AffectedEntity.ConstantField);
}
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new FieldDeclaration()
{
ReturnType = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
var variableUsage = new IdentifierExpression(name);
script.Replace(pexpr, variableUsage);
// script.Link(initializer.NameToken, variableUsage);
script.InsertWithCursor(context.TranslateString("Create constant"), decl, Script.InsertPosition.Before);
}));
}
bool IsEquivalentField(FieldDeclaration field1, FieldDeclaration field2)
{
return(field1.Variables.Any(variable1 => {
return field2.Variables.Any(variable2 => variable1.Name == variable2.Name);
}));
}
private void ProcessEnum(TypeScriptContext tsc, ModuleDeclaration module, HtmlNode h3, string name)
{
var div = h3.ParentNode;
var enumType = div.SelectSingleNode("*[@class='type-signature']")?.InnerText.Trim();
var desc = div.SelectNodes("p[not(@class)]").SanitizeDocumentation();
TypeDeclaration td;
ITypeScriptType ft;
IList fs;
if (!StringEnumAsClass || enumType == null || enumType.Equals("number"))
{
var ed = new EnumDeclaration();
td = ed;
ft = ed;
fs = ed.Members;
}
else
{
var ct = new ClassDeclaration();
td = ct;
ft = ResolveType(tsc, enumType).Type;
fs = ct.Members;
}
td.IsExport = true;
td.Name = name;
if (desc != null)
{
td.Documentation = new Documentation()
{
Summary = desc
};
}
module.Statements.Add(td);
var e = new TypeEventArgs(td);
TypeParsing?.Invoke(this, e);
var trs = div.SelectNodes("section//table/tbody/tr");
if (trs != null)
{
foreach (var tr in trs)
{
var mn = tr.SelectSingleNode("td[1]")?.InnerText?.Trim();
if (mn != null)
{
var md = tr.SelectNodes("td[2]").SanitizeDocumentation();
var f = new FieldDeclaration();
f.AccessModifier = AccessModifier.Public;
f.IsStatic = true;
f.Name = mn;
f.FieldType = ft;
if (md != null)
{
f.Documentation = new Documentation()
{
Summary = md
};
}
fs.Add(f);
}
}
}
TypeParsed?.Invoke(this, e);
}
public override void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
{
//ignore fields
}
public static List <string> names(this FieldDeclaration fieldDeclaration)
{
return((from field in fieldDeclaration.Fields
select field.Name).toList());
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode <PropertyDeclaration> ();
if (property == null ||
!IsNotImplemented(context, property.Getter.Body) ||
!IsNotImplemented(context, property.Setter.Body))
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Implement property"), script => {
string backingStoreName = context.GetNameProposal(property.Name);
// create field
var backingStore = new FieldDeclaration();
if (property.Modifiers.HasFlag(Modifiers.Static))
{
backingStore.Modifiers |= Modifiers.Static;
}
if (property.Setter.IsNull)
{
backingStore.Modifiers |= Modifiers.Readonly;
}
backingStore.ReturnType = property.ReturnType.Clone();
var initializer = new VariableInitializer(backingStoreName);
backingStore.Variables.Add(initializer);
// create new property & implement the get/set bodies
var newProperty = (PropertyDeclaration)property.Clone();
Expression id1;
if (backingStoreName == "value")
{
id1 = new ThisReferenceExpression().Member("value");
}
else
{
id1 = new IdentifierExpression(backingStoreName);
}
Expression id2 = id1.Clone();
newProperty.Getter.Body = new BlockStatement()
{
new ReturnStatement(id1)
};
if (!property.Setter.IsNull)
{
newProperty.Setter.Body = new BlockStatement()
{
new AssignmentExpression(id2, AssignmentOperatorType.Assign, new IdentifierExpression("value"))
};
}
script.Replace(property, newProperty);
script.InsertBefore(property, backingStore);
if (!property.Setter.IsNull)
{
script.Link(initializer, id1, id2);
}
else
{
script.Link(initializer, id1);
}
}, property.NameToken));
}
public static FieldDeclaration add_Field(this CompilationUnit compilationUnit, IField iField, FieldDeclaration fieldDeclaration)
{
var fieldType = compilationUnit.add_Type(iField.DeclaringType);
return(fieldType.add_Field(fieldDeclaration));
}
public override void VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
{
}
public static FieldDeclaration add_Field(this TypeDeclaration typeDeclaration, FieldDeclaration fieldDeclaration)
{
if (typeDeclaration.notNull() && fieldDeclaration.notNull() && typeDeclaration.Children.notNull())
{
//var insertPosition = typeDeclaration.Children.Count;
var insertPosition = 0; // fields are OK to go at the top
typeDeclaration.Children.Insert(insertPosition, fieldDeclaration);
}
return(fieldDeclaration);
}