//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected ISyntaxEmitter CreateMemberSyntaxEmitter(AbstractMember member)
{
if (member is FieldMember field)
{
return(new FieldSyntaxEmitter(field));
}
if (member is ConstructorMember constructor)
{
return(new ConstructorSyntaxEmitter(constructor));
}
if (member is MethodMember method)
{
return(new MethodSyntaxEmitter(method));
}
if (member is PropertyMember property)
{
return(new PropertySyntaxEmitter(property));
}
if (member is EventMember @event)
{
return(new EventSyntaxEmitter(@event));
}
if (member is TypeMember type)
{
return(TypeSyntaxEmitter.GetSyntaxEmitter(type));
}
throw new ArgumentException($"Syntax emitter is not supported for members of type {member.GetType().Name}");
}
private static void AddVisibilitySyntax(AbstractMember member, List <SyntaxToken> syntax)
{
switch (member.Visibility)
{
case MemberVisibility.Public:
syntax.Add(Token(SyntaxKind.PublicKeyword));
break;
case MemberVisibility.Private:
syntax.Add(Token(SyntaxKind.PrivateKeyword));
break;
case MemberVisibility.Protected:
syntax.Add(Token(SyntaxKind.ProtectedKeyword));
break;
case MemberVisibility.Internal:
syntax.Add(Token(SyntaxKind.InternalKeyword));
break;
case MemberVisibility.InternalProtected:
syntax.Add(Token(SyntaxKind.InternalKeyword));
syntax.Add(Token(SyntaxKind.ProtectedKeyword));
break;
case MemberVisibility.PrivateProtected:
syntax.Add(Token(SyntaxKind.PrivateKeyword));
syntax.Add(Token(SyntaxKind.ProtectedKeyword));
break;
}
}
public static void WriteMember(CodeTextBuilder code, AbstractMember member)
{
WriteExportModifiers(code, member);
if (member is TypeMember type && type.TypeKind == TypeMemberKind.Class)
{
JavaScriptClassWriter.WriteClass(code, type);
}
public static MemberExpression Create(AbstractExpression target, AbstractMember member)
{
return(BlockContext.GetBlockOrThrow().PushExpression(new MemberExpression {
Type = target.Type,
Target = target,
Member = member
}));
}
void TestMember(string className, string memberName)
{
IClass c = mscorlib.GetClassByReflectionName(className, false);
Assert.IsNotNull(c);
AbstractMember m = (AbstractMember)DefaultProjectContent.GetMemberByReflectionName(c, memberName);
Assert.AreEqual(className + "." + memberName, m.DocumentationTag.Substring(2));
}
public static MemberDeclarationSyntax GetSyntax(AbstractMember member)
{
if (member is TypeMember type)
{
return(GetTypeSyntax(type));
}
throw new NotImplementedException();
}
static void AddExplicitInterfaces (AbstractMember member, IEnumerable<ICSharpCode.NRefactory.Ast.InterfaceImplementation> interfaceImplementations)
{
if (interfaceImplementations == null)
return;
foreach (ICSharpCode.NRefactory.Ast.InterfaceImplementation impl in interfaceImplementations) {
member.AddExplicitInterface (ConvertReturnType (impl.InterfaceType));
}
}
public static SyntaxTokenList GetModifierSyntax(AbstractMember member)
{
var syntaxList = new List <SyntaxToken>();
AddVisibilitySyntax(member, syntaxList);
AddModifierSyntax(member, syntaxList);
return(TokenList(syntaxList));
}
void AddInterfaceImplementations(AbstractMember member, AST.MemberNode memberNode)
{
member.InterfaceImplementations.AddRange(
memberNode.InterfaceImplementations
.Select(x => new ExplicitInterfaceImplementation(CreateReturnType(x.InterfaceType), x.MemberName))
);
if (!IsVisualBasic && member.InterfaceImplementations.Any())
{
member.Modifiers = ConvertModifier(memberNode.Modifier, ModifierEnum.None);
}
}
public static SyntaxList <AttributeListSyntax> GetAttributeListSyntax(AbstractMember member)
{
return(List(
member.Attributes.Select(attr =>
AttributeList(
SingletonSeparatedList(
GetAttributeSyntax(attr)
)
)
)
));
}
public bool?BuildUI()
{
Type type = Instance.GetType();
Grid grid = BuildGrid();
Window window = BuildWindow();
window.Content = (grid);
foreach (var member in type.GetMembers())
{
AbstractMember abstractMember = null;
if (member.MemberType == MemberTypes.Property)
{
abstractMember = new PropertyMember((PropertyInfo)member);
}
else if (member.MemberType == MemberTypes.Field)
{
abstractMember = new FieldMember((FieldInfo)member);
}
if (abstractMember != null)
{
BuildControl(grid, abstractMember, Instance);
}
}
PopulateControls(Instance);
StackPanel panel = BuildButtonPanel(window);
grid.RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(40)
});
Grid.SetRow(panel, grid.RowDefinitions.Count - 1);
Grid.SetColumn(panel, 2);
grid.Children.Add(panel);
grid.Height = grid.RowDefinitions.Sum(o => o.Height.Value);
grid.Width = grid.ColumnDefinitions.Sum(o => o.Width.Value);
window.Height = grid.Height + 60;
window.Width = grid.Width + 40;
window.Owner = System.Windows.Application.Current.MainWindow;
return(window.ShowDialog());
}
static void AddAttributes (AbstractMember member, IEnumerable<ICSharpCode.NRefactory.Ast.AttributeSection> attributes)
{
CodeDomVisitor domVisitor = new CodeDomVisitor ();
foreach (ICSharpCode.NRefactory.Ast.AttributeSection attributeSection in attributes) {
foreach (ICSharpCode.NRefactory.Ast.Attribute attribute in attributeSection.Attributes) {
DomAttribute domAttribute = new DomAttribute ();
domAttribute.Name = attribute.Name;
domAttribute.Region = ConvertRegion (attribute.StartLocation, attribute.EndLocation);
domAttribute.AttributeType = new DomReturnType (attribute.Name);
member.Add (domAttribute);
foreach (ICSharpCode.NRefactory.Ast.Expression exp in attribute.PositionalArguments)
domAttribute.AddPositionalArgument ((CodeExpression)exp.AcceptVisitor (domVisitor, null));
foreach (ICSharpCode.NRefactory.Ast.NamedArgumentExpression nexp in attribute.NamedArguments)
domAttribute.AddNamedArgument (nexp.Name, (CodeExpression)nexp.Expression.AcceptVisitor (domVisitor, null));
}
}
}
public virtual AttributedNode GetOverridingMethod(IMember baseMember, ClassFinder targetContext)
{
AbstractMember newMember = (AbstractMember)baseMember.Clone();
newMember.Modifiers &= ~(ModifierEnum.Virtual | ModifierEnum.Abstract);
newMember.Modifiers |= ModifierEnum.Override;
// set modifiers be before calling convert so that a body is generated
AttributedNode node = ConvertMember(newMember, targetContext);
node.Attributes.Clear(); // don't copy over attributes
if (!baseMember.IsAbstract)
{
// replace the method/property body with a call to the base method/property
MethodDeclaration method = node as MethodDeclaration;
if (method != null)
{
method.Body.Children.Clear();
if (method.TypeReference.Type == "System.Void")
{
method.Body.AddChild(new ExpressionStatement(CreateForwardingMethodCall(method)));
}
else
{
method.Body.AddChild(new ReturnStatement(CreateForwardingMethodCall(method)));
}
}
PropertyDeclaration property = node as PropertyDeclaration;
if (property != null)
{
Expression field = new BaseReferenceExpression().Member(property.Name);
if (!property.GetRegion.Block.IsNull)
{
property.GetRegion.Block.Children.Clear();
property.GetRegion.Block.Return(field);
}
if (!property.SetRegion.Block.IsNull)
{
property.SetRegion.Block.Children.Clear();
property.SetRegion.Block.Assign(field, new IdentifierExpression("value"));
}
}
}
return(node);
}
private static void AddModifierSyntax(AbstractMember member, List <SyntaxToken> syntax)
{
switch (member.Modifier)
{
case MemberModifier.Abstract:
syntax.Add(Token(SyntaxKind.PublicKeyword));
break;
case MemberModifier.Override:
syntax.Add(Token(SyntaxKind.OverrideKeyword));
break;
case MemberModifier.Static:
syntax.Add(Token(SyntaxKind.StaticKeyword));
break;
case MemberModifier.Virtual:
syntax.Add(Token(SyntaxKind.VirtualKeyword));
break;
}
}
public static AbstractExpression DOT(this LocalVariable target, AbstractMember member) => null;
public static AbstractExpression DOT(this AbstractExpression target, AbstractMember member) => null;
static void ReadMemberInformation(BinaryReader reader, INameDecoder nameTable, AbstractMember member)
{
member.Name = ReadString(reader, nameTable);
member.Documentation = ReadString(reader, nameTable);
member.Modifiers = (Modifiers)reader.ReadUInt32();
member.Location = ReadLocation(reader, nameTable);
uint count = ReadUInt(reader, 1000);
while (count-- > 0)
{
member.Add(ReadAttribute(reader, nameTable));
}
}
private string GetSymbolName(AbstractMember member)
{
return(member.Bindings.OfType <ISymbol>().Single().Name);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected Exception NewValidationException(TypeMember type, AbstractMember member, string message, Exception inner = null)
{
throw new NotImplementedException();
}
public static AbstractExpression DOT(this AbstractExpression target, AbstractMember member)
=> PushExpression(new MemberExpression {
Target = PopExpression(target),
Member = member
});
public static AbstractExpression DOT(this LocalVariable target, AbstractMember member)
=> PushExpression(new MemberExpression {
Type = target.Type,
Target = PopExpression(target.AsExpression()),
Member = member
});
public static AbstractExpression DOT(this MethodParameter target, AbstractMember member) => null;
public static AbstractExpression DOT(this MethodParameter target, AbstractMember member)
=> PushExpression(new MemberExpression {
Type = target.Type,
Target = PopExpression(target.AsExpression()),
Member = member
});
//public void BindMember<TBinding>(MemberRef<AbstractMember> member, TBinding binding)
// where TBinding : class
//{
// member.Bindings.Add(binding);
// _memberByBinding[binding] = member;
//}
public void RegisterMember(AbstractMember member, bool isTopLevel)
{
_codeModel.Add(member, isTopLevel);
}
public static AbstractExpression ASSIGN(this AbstractMember target, AbstractExpression value) => null;
protected internal virtual void VisitAbstractMember(AbstractMember member)
{
}
void BuildControl(Grid grid, AbstractMember member, PluginConfigurationOptions pluginConfigurationOptions)
{
Control control = null;
object[] attributes = member.GetAttributes();
if (attributes == null || attributes.Length == 0)
{
return;
}
LabelAttribute labelAttribute = attributes.Select(x => x as LabelAttribute).Where(i => i != null).First();
bool isBool = member.Type == typeof(bool);
bool isString = member.Type == typeof(string);
bool isChoice = attributes.FirstOrDefault(x => x is ItemsAttribute) != null;
if (isBool)
{
control = new CheckBox()
{
VerticalAlignment = VerticalAlignment.Center, IsChecked = (bool)member.Read(pluginConfigurationOptions), Name = member.Name
};
(control as CheckBox).Checked += new RoutedEventHandler(PluginConfigureView_Checked);
(control as CheckBox).Unchecked += new RoutedEventHandler(PluginConfigureView_Checked);
}
else if (isChoice)
{
control = new ComboBox()
{
Margin = new Thickness(0, 2, 0, 2), Name = member.Name, Width = 200
};
(control as ComboBox).SelectionChanged += new SelectionChangedEventHandler(PluginConfigureView_SelectionChanged);
ItemsAttribute itemsAttribute = attributes.Select(x => x as ItemsAttribute).Where(i => i != null).First();
foreach (var item in itemsAttribute.Items.Split(','))
{
(control as ComboBox).Items.Add(item);
}
(control as ComboBox).Text = (string)member.Read(pluginConfigurationOptions);
}
else if (isString)
{
control = new TextBox()
{
Margin = new Thickness(0, 2, 0, 2), Text = (string)member.Read(pluginConfigurationOptions), Name = member.Name, Width = 200
};
(control as TextBox).TextChanged += new TextChangedEventHandler(PluginConfigureView_TextChanged);
}
else
{
return;
}
grid.RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(30)
});
Label label = new Label()
{
Margin = new Thickness(0, 0, 10, 0), HorizontalAlignment = HorizontalAlignment.Right, Content = labelAttribute.Label
};
grid.Children.Add(label);
Grid.SetColumn(label, 0);
Grid.SetRow(label, grid.RowDefinitions.Count - 1);
grid.Children.Add(control);
Grid.SetColumn(control, 1);
Grid.SetRow(control, grid.RowDefinitions.Count - 1);
_controlBindings.Add(control, member);
}
public static bool HasAttribute <TAttribute>(this AbstractMember member)
where TAttribute : System.Attribute
{
return(TryGetAttribute <TAttribute>(member) != null);
}
static void ReadMemberInformation (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable, AbstractMember member)
{
member.Name = ReadString (reader, nameTable);
member.Documentation = ReadString (reader, nameTable);
member.Modifiers = (Modifiers)reader.ReadUInt32();
member.Location = ReadLocation (reader, nameTable);
uint count = ReadUInt (reader, 1000);
while (count-- > 0)
member.Add (ReadAttribute (reader, nameTable, objectTable));
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
internal protected override void VisitAbstractMember(AbstractMember member)
{
base.VisitAbstractMember(member);
_visitLog.Add(new Visit(nameof(VisitAbstractMember), member));
}
void AddInterfaceImplementations(AbstractMember member, AST.MemberNode memberNode)
{
member.InterfaceImplementations.AddRange(
memberNode.InterfaceImplementations
.Select(x => new ExplicitInterfaceImplementation(CreateReturnType(x.InterfaceType), x.MemberName))
);
if (!IsVisualBasic && member.InterfaceImplementations.Any()) {
member.Modifiers = ConvertModifier(memberNode.Modifier, ModifierEnum.None);
}
}
public static AttributeDescription TryGetAttribute(this AbstractMember member, string namespaceQualifiedTypeName)
{
return(member.Attributes.FirstOrDefault(attr => attr.AttributeType.FullName == namespaceQualifiedTypeName));
}
