void BuildSql(MemberNode memberNode)
{
_builder.QueryByField(memberNode.TableName, memberNode.FieldName,
_operationDictionary[ExpressionType.Equal], true);
}
private void BuildSql(MemberNode memberNode)
{
QueryByField(memberNode.TableName, memberNode.FieldName, Helpers.Helper.GetOperator(ExpressionType.Equal), true);
}
private void BuildSql(MemberNode leftMember, MemberNode rightMember, ExpressionType op)
{
QueryByFieldComparison(leftMember.TableName, leftMember.FieldName, Helpers.Helper.GetOperator(op), rightMember.TableName, rightMember.FieldName);
}
private void BuildMemberDetails(MemberSymbol memberSymbol, TypeSymbol typeSymbol, MemberNode memberNode, ParseNodeList attributes)
{
if (memberSymbol.Type != SymbolType.EnumerationField)
{
memberSymbol.SetVisibility(GetVisibility(memberNode, typeSymbol));
}
bool preserveCase = (AttributeNode.FindAttribute(attributes, "PreserveCase") != null);
memberSymbol.SetNameCasing(preserveCase);
string scriptName = GetAttributeValue(attributes, "ScriptName");
if (scriptName != null)
{
memberSymbol.SetTransformedName(scriptName);
}
else if (AttributeNode.FindAttribute(attributes, "PreserveName") != null)
{
memberSymbol.DisableNameTransformation();
}
}
bool IParseNodeValidator.Validate(ParseNode node, CompilerOptions options, IErrorHandler errorHandler)
{
CustomTypeNode typeNode = (CustomTypeNode)node;
bool restrictToMethodMembers = false;
bool hasCodeMembers = false;
ParseNode codeMemberNode = null;
AttributeNode importedTypeAttribute = AttributeNode.FindAttribute(typeNode.Attributes, "Imported");
if (importedTypeAttribute != null)
{
// This is an imported type definition... we'll assume its valid, since
// the set of restrictions for such types is fewer, and different, so
// for now that translates into skipping the members.
return(false);
}
AttributeNode scriptNamespaceNode = AttributeNode.FindAttribute(typeNode.Attributes, "ScriptNamespace");
if (scriptNamespaceNode != null)
{
string scriptNamespace = (string)((LiteralNode)scriptNamespaceNode.Arguments[0]).Value;
if (Utility.IsValidScriptNamespace(scriptNamespace) == false)
{
errorHandler.ReportError("A script namespace must be a valid script identifier.",
scriptNamespaceNode.Token.Location);
}
}
if (typeNode.Type == TokenType.Struct)
{
errorHandler.ReportError("Struct types are not supported. Use classes annotated with the Record metadata attribute.",
typeNode.Token.Location);
return(false);
}
if (((typeNode.Modifiers & Modifiers.Partial) != 0) &&
(typeNode.Type != TokenType.Class))
{
errorHandler.ReportError("Partial types can only be classes, not enumerations or interfaces.",
typeNode.Token.Location);
return(false);
}
if ((typeNode.Type == TokenType.Interface) &&
(typeNode.BaseTypes.Count != 0))
{
errorHandler.ReportError("Derived interface types are not supported.",
typeNode.Token.Location);
return(false);
}
if (typeNode.Type == TokenType.Class)
{
if (typeNode.BaseTypes.Count != 0)
{
NameNode baseTypeNameNode = typeNode.BaseTypes[0] as NameNode;
if (baseTypeNameNode != null)
{
if (String.CompareOrdinal(baseTypeNameNode.Name, "Record") == 0)
{
if ((typeNode.Modifiers & Modifiers.Sealed) == 0)
{
errorHandler.ReportError("Classes derived from the Record base class must be marked as sealed.",
typeNode.Token.Location);
}
if (typeNode.BaseTypes.Count != 1)
{
errorHandler.ReportError("Classes derived from the Record base class cannot implement interfaces.",
typeNode.Token.Location);
}
}
else if (String.CompareOrdinal(baseTypeNameNode.Name, "TestClass") == 0)
{
if ((typeNode.Modifiers & Modifiers.Internal) == 0)
{
errorHandler.ReportError("Classes derived from TestClass must be marked as internal.",
typeNode.Token.Location);
}
if ((typeNode.Modifiers & Modifiers.Static) != 0)
{
errorHandler.ReportError("Classes derived from TestClass must not be marked as static.",
typeNode.Token.Location);
}
if ((typeNode.Modifiers & Modifiers.Sealed) == 0)
{
errorHandler.ReportError("Classes derived from TestClass must be marked as sealed.",
typeNode.Token.Location);
}
if (typeNode.BaseTypes.Count != 1)
{
errorHandler.ReportError("Classes derived from TestClass cannot implement interfaces.",
typeNode.Token.Location);
}
}
}
}
AttributeNode globalMethodsAttribute = AttributeNode.FindAttribute(typeNode.Attributes, "GlobalMethods");
if (globalMethodsAttribute != null)
{
restrictToMethodMembers = true;
if ((typeNode.Modifiers & Modifiers.Static) == 0)
{
errorHandler.ReportError("GlobalMethods attribute can only be set on static classes.",
typeNode.Token.Location);
}
}
AttributeNode mixinAttribute = AttributeNode.FindAttribute(typeNode.Attributes, "Mixin");
if (mixinAttribute != null)
{
restrictToMethodMembers = true;
if ((typeNode.Modifiers & Modifiers.Static) == 0)
{
errorHandler.ReportError("Mixin attribute can only be set on static classes.",
typeNode.Token.Location);
}
}
}
if ((typeNode.Members != null) && (typeNode.Members.Count != 0))
{
Dictionary <string, object> memberNames = new Dictionary <string, object>();
bool hasCtor = false;
foreach (ParseNode genericMemberNode in typeNode.Members)
{
if (!(genericMemberNode is MemberNode))
{
errorHandler.ReportError("Only members are allowed inside types. Nested types are not supported.",
node.Token.Location);
continue;
}
MemberNode memberNode = (MemberNode)genericMemberNode;
if ((memberNode.Modifiers & Modifiers.Extern) != 0)
{
// Extern methods are placeholders for creating overload signatures
continue;
}
if (restrictToMethodMembers &&
(memberNode.NodeType != ParseNodeType.MethodDeclaration) &&
(memberNode.NodeType != ParseNodeType.ConstructorDeclaration))
{
errorHandler.ReportError("Classes marked with GlobalMethods or Mixin attribute should only have methods.",
memberNode.Token.Location);
}
if (memberNode.NodeType == ParseNodeType.ConstructorDeclaration)
{
if ((memberNode.Modifiers & Modifiers.Static) == 0)
{
if (hasCtor)
{
errorHandler.ReportError("Constructor overloads are not supported.",
memberNode.Token.Location);
}
hasCtor = true;
}
continue;
}
if (memberNode.NodeType == ParseNodeType.OperatorDeclaration)
{
// Operators don't have a name
continue;
}
string name = memberNode.Name;
if (memberNames.ContainsKey(name))
{
errorHandler.ReportError("Duplicate-named member. Method overloads are not supported.",
memberNode.Token.Location);
}
memberNames[name] = null;
bool preserveCase = (AttributeNode.FindAttribute(memberNode.Attributes, "PreserveCase") != null);
if (Utility.IsKeyword(name, /* testCamelCase */ (preserveCase == false)))
{
errorHandler.ReportError("Invalid member name. Member names should not use keywords.",
memberNode.Token.Location);
}
if (hasCodeMembers == false)
{
hasCodeMembers = ((memberNode.NodeType == ParseNodeType.PropertyDeclaration) ||
(memberNode.NodeType == ParseNodeType.MethodDeclaration) ||
(memberNode.NodeType == ParseNodeType.EventDeclaration) ||
(memberNode.NodeType == ParseNodeType.IndexerDeclaration));
codeMemberNode = memberNode;
}
}
}
if ((typeNode.Type == TokenType.Struct) && hasCodeMembers)
{
errorHandler.ReportError("A struct type is limited to field and constructor members.",
codeMemberNode.Token.Location);
}
return(true);
}
private void GenerateGetObject(CodeMemberMethod initComponentMethod, CodeExpression parentExpression, CodeDomObjectNode targetObjectNode, MemberNode parentMember)
{
if (parentMember.Member.IsAttachable)
{
throw new NotImplementedException();
}
CodePropertyReferenceExpression cpfe = new CodePropertyReferenceExpression(parentExpression, parentMember.Member.Name);
Type type = parentMember.Member.Type.UnderlyingType;
string targetName = GenerateUniqueName(type);
CodeVariableDeclarationStatement cvds = new CodeVariableDeclarationStatement(type.Name, targetName, cpfe);
initComponentMethod.Statements.Add(cvds);
CodeVariableReferenceExpression cvre = new CodeVariableReferenceExpression(targetName);
AddMembers(initComponentMethod, cvre, targetObjectNode);
}
private void GenerateMemberAssignment(CodeMemberMethod initComponentMethod, MemberNode member, CodeExpression targetExpression, CodeExpression valueExpression, CodeDomObjectNode targetObjectNode)
{
CodeStatement cs = null;
//if (member.Member.IsUnknown)
//{
// throw new Exception("Unknown member " + member.Member.Name);
//}
if (member.Member == XamlLanguage.Items)
{
ObjectNode parentObjectNode = member.ParentObjectNode;
XamlType parentType = null;
if (parentObjectNode.IsGetObject)
{
parentType = parentObjectNode.ParentMemberNode.Member.Type;
}
else
{
parentType = parentObjectNode.Type;
}
if (parentType.IsDictionary)
{
if (!typeof(IDictionary).IsAssignableFrom(parentType.UnderlyingType))
{
throw new NotImplementedException("Support non-IDictionary adds");
}
CodeExpression keyExpression;
if (targetObjectNode.XKeyNode != null)
{
keyExpression = new CodeSnippetExpression("\"" + ((ValueNode)targetObjectNode.XKeyNode.ItemNodes[0]).Value + "\"");
}
else
{
if (targetObjectNode.DictionaryKeyProperty == null)
{
throw new NotSupportedException("No key on dictionary entry");
}
throw new NotImplementedException();
}
cs = new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeCastExpression(typeof(IDictionary), targetExpression), "Add", keyExpression, valueExpression));
}
else
{
if (!typeof(IList).IsAssignableFrom(parentType.UnderlyingType))
{
throw new NotImplementedException("Support non-IList adds");
}
//TODO: calling Add directly is how I'll leave it for now...
//cs = new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeCastExpression(typeof(IList), targetExpression), "Add", valueExpression));
cs = new CodeExpressionStatement(new CodeMethodInvokeExpression(targetExpression, "Add", valueExpression));
}
}
else if (member.Member.IsEvent)
{
throw new NotImplementedException();
}
else
{
if (member.Member.IsAttachable)
{
cs = new CodeExpressionStatement(new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(member.Member.DeclaringType.UnderlyingType.Name),
"Set" + member.Member.Name), targetExpression, valueExpression));
}
else //normal property
{
cs = new CodeAssignStatement(
new CodePropertyReferenceExpression(targetExpression, member.Member.Name), valueExpression);
}
}
initComponentMethod.Statements.Add(cs);
}
private void BuildSql(MemberNode leftMember, MemberNode rightMember, ExpressionType op)
{
var newCondition = $"{Field(leftMember.TableName, leftMember.FieldName)} {_operationDictionary[op]} {Field(rightMember.TableName, rightMember.FieldName)}";
_conditions.Add(newCondition);
}
public void BuildWhere(MemberNode memberNode)
{
AddCondition(memberNode.TableName, memberNode.FieldName, _operations[ExpressionType.Equal], true);
}
protected override IEnumerable <JsonCompletionEntry> GetEntries(JsonCompletionContext context)
{
MemberNode member = context.ContextNode.FindType <MemberNode>();
if (member == null || member.UnquotedNameText != "files")
{
yield break;
}
var parent = member.Parent as ObjectNode;
if (!JsonHelpers.TryGetInstallationState(parent, out ILibraryInstallationState state))
{
yield break;
}
if (string.IsNullOrEmpty(state.Name))
{
yield break;
}
IDependencies dependencies = _dependenciesFactory.FromConfigFile(ConfigFilePath);
IProvider provider = dependencies.GetProvider(state.ProviderId);
ILibraryCatalog catalog = provider?.GetCatalog();
if (catalog == null)
{
yield break;
}
Task <ILibrary> task = catalog.GetLibraryAsync(state.Name, state.Version, CancellationToken.None);
FrameworkElement presenter = GetPresenter(context);
IEnumerable <string> usedFiles = GetUsedFiles(context);
if (task.IsCompleted)
{
if (!(task.Result is ILibrary library))
{
yield break;
}
foreach (string file in library.Files.Keys)
{
if (!usedFiles.Contains(file))
{
ImageMoniker glyph = WpfUtil.GetImageMonikerForFile(file);
yield return(new SimpleCompletionEntry(file, glyph, context.Session));
}
}
}
else
{
yield return(new SimpleCompletionEntry(Resources.Text.Loading, string.Empty, KnownMonikers.Loading, context.Session));
_ = task.ContinueWith(async(t) =>
{
await VisualStudio.Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (!(t.Result is ILibrary library))
{
return;
}
if (!context.Session.IsDismissed)
{
var results = new List <JsonCompletionEntry>();
foreach (string file in library.Files.Keys)
{
if (!usedFiles.Contains(file))
{
ImageMoniker glyph = WpfUtil.GetImageMonikerForFile(file);
results.Add(new SimpleCompletionEntry(file, glyph, context.Session));
}
}
UpdateListEntriesSync(context, results);
}
}, TaskScheduler.Default);
}
}
public void WriteSyntax(UdnWriter Writer)
{
List <string> Lines = new List <string>();
Lines.Add(String.Format("{0} {1}", Entity.Node.Attributes["kind"].Value, Entity.Name));
Lines.Add("(");
using (XmlNodeList MemberNodeList = Entity.Node.SelectNodes("sectiondef/memberdef"))
{
foreach (XmlNode MemberNode in MemberNodeList)
{
if (MemberNode.Attributes["kind"].Value == "variable")
{
Lines.Add(UdnWriter.TabSpaces + String.Format("{0} {1};", ConvertToMarkdown(MemberNode.SelectSingleNode("type")), MemberNode.SelectSingleNode("name").InnerText));
}
else if (MemberNode.Attributes["kind"].Value == "function")
{
Lines.Add(UdnWriter.TabSpaces);
Lines.Add(UdnWriter.TabSpaces + "// " + ConvertToMarkdown(MemberNode.SelectSingleNode("briefdescription")).Replace('\r', ' ').Replace('\n', ' ').Trim());
Lines.Add(UdnWriter.TabSpaces + ConvertFunctionNodeToMarkdown(MemberNode));
}
}
}
Lines.Add(")");
WriteNestedSimpleCode(Writer, Lines);
}
public override void Run()
{
IClass c;
IMember m;
MemberNode mn = this.Owner as MemberNode;
if (mn != null)
{
m = mn.Member;
c = m.DeclaringType;
}
else
{
ClassNode cn = this.Owner as ClassNode;
if (cn != null)
{
c = cn.Class;
m = null;
}
else
{
ClassMemberBookmark cmbm = this.Owner as ClassMemberBookmark;
if (cmbm != null)
{
m = cmbm.Member;
c = m.DeclaringType;
}
else
{
ClassBookmark cbm = this.Owner as ClassBookmark;
if (cbm != null)
{
c = cbm.Class;
m = null;
}
else
{
MessageService.ShowWarning("Reflector AddIn: Could not determine the class for the selected element. Owner: " + ((this.Owner == null) ? "<null>" : this.Owner.ToString()));
return;
}
}
}
}
if (c == null)
{
MessageService.ShowWarning("Reflector AddIn: Could not determine the class for the selected element (known owner). Owner: " + this.Owner.ToString());
return;
}
// Try to find the assembly which contains the resolved type
IProjectContent pc = c.ProjectContent;
ReflectionProjectContent rpc = pc as ReflectionProjectContent;
string assemblyLocation = null;
if (rpc != null)
{
assemblyLocation = rpc.AssemblyLocation;
}
else
{
IProject project = pc.Project as IProject;
if (project != null)
{
assemblyLocation = project.OutputAssemblyFullPath;
}
}
if (String.IsNullOrEmpty(assemblyLocation))
{
MessageService.ShowWarning("Reflector AddIn: Could not determine the assembly location for " + c.ToString() + ".");
return;
}
AbstractEntity entity = m as AbstractEntity;
if (entity == null)
{
entity = c as AbstractEntity;
}
if (entity != null)
{
LoggingService.Debug("ReflectorAddIn: Trying to go to " + entity.DocumentationTag + " in " + assemblyLocation);
ReflectorController.TryGoTo(assemblyLocation, entity);
}
}
private Type GetBinderType(MemberNode memberNode)
{
return(typeof(Action <, ,>).MakeGenericType(memberNode.Metadata.Parent.Type, typeof(int), memberNode.Metadata.Type));
}
private IEnumerable <MemberNode> GetFieldNodes(MemberNode node)
{
return(node.EnumerateNodes().Skip(1).Where(n => n.HasFlag(NodeFlags.Field)));
}
protected virtual string TranslateMemberNode(MemberNode m)
{
return _fieldTranslator.Translate(m.Member);
}
void BuildWhere(MemberNode n, InNode node, ExpressionType op)
{
BuildWhere(node);
}
// MyData myDataObject = new MyData(DateTime.Now);
// Binding myBinding = new Binding("MyDataProperty");
// myBinding.Source = myDataObject;
// myText.SetBinding(TextBlock.TextProperty, myBinding);
private void GenerateBindingObject(CodeMemberMethod initComponentMethod, CodeExpression parentExpression, CodeDomObjectNode targetObjectNode, MemberNode parentMember)
{
// Generate new binding name
string targetName = GenerateUniqueName(targetObjectNode.Type);
string elementName = string.Empty;
string path = string.Empty;
// Grab all the attributes of the binding
NodeCollection <MemberNode> members = targetObjectNode.MemberNodes;
foreach (MemberNode member in members)
{
switch (member.Member.Name)
{
case "ElementName":
elementName = ExtractItemMemberValue(member.ItemNodes[0]);
break;
case "Path":
path = ExtractItemMemberValue(member.ItemNodes[0]);
break;
}
}
// Create a constructor for the binding adding the Path, if it exists
CodeExpression ctor = new CodeObjectCreateExpression(targetObjectNode.Type.UnderlyingType.Name, new CodePrimitiveExpression(path));
CodeVariableDeclarationStatement cvds = new CodeVariableDeclarationStatement(targetObjectNode.Type.UnderlyingType.Name, targetName, ctor);
initComponentMethod.Statements.Add(cvds);
// Set the source property on the binding
CodeStatement cs = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(targetName), "Source"), new CodeVariableReferenceExpression(elementName));
initComponentMethod.Statements.Add(cs);
// Set the binding on the target object
CodeFieldReferenceExpression cfre = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(parentMember.ParentObjectNode.Type.UnderlyingType), parentMember.Member.Name + "Property");
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(parentExpression, "SetBinding", new CodeExpression[] { cfre, new CodeVariableReferenceExpression(targetName) });
initComponentMethod.Statements.Add(cmie);
}
void BuildWhere(ValueNode valueNode, MemberNode memberNode, ExpressionType op)
{
BuildWhere(memberNode, valueNode, op);
}
private void GenerateObject(CodeMemberMethod initComponentMethod, CodeExpression parentExpression, CodeDomObjectNode targetObjectNode, MemberNode parentMember)
{
string targetName;
bool isPublicObject = false;
if (targetObjectNode.XNameNode == null)
{
targetName = GenerateUniqueName(targetObjectNode.Type);
}
else
{
ValueNode valueNode = targetObjectNode.XNameNode.ItemNodes[0] as ValueNode;
targetName = (string)valueNode.Value;
isPublicObject = true;
}
CodeExpression ctor = null;
if (targetObjectNode.XInitNode != null)
{
string tcName = GenerateTypeConverter(initComponentMethod, targetObjectNode.Type); // TextSyntax
ctor = GetTypeConverteredValue(targetObjectNode.Type, ((ValueNode)targetObjectNode.XInitNode.ItemNodes[0]).Value, targetObjectNode.Type.UnderlyingType, tcName);
}
else if (targetObjectNode.XFactoryMethodNode != null)
{
throw new NotImplementedException();
}
else if (targetObjectNode.XPosParamsNode != null)
{
IList <XamlType> types = targetObjectNode.Type.GetPositionalParameters(targetObjectNode.XPosParamsNode.ItemNodes.Count);
CodeObjectCreateExpression constructor = new CodeObjectCreateExpression(targetObjectNode.Type.UnderlyingType.Name);
for (int i = 0; i < types.Count; i++)
{
string tcName = GenerateTypeConverter(initComponentMethod, types[i]);
constructor.Parameters.Add(GetTypeConverteredValue(types[i], ((ValueNode)targetObjectNode.XPosParamsNode.ItemNodes[i]).Value, types[i].UnderlyingType, tcName));
}
ctor = constructor;
}
else if (targetObjectNode.XArgumentsNode != null)
{
throw new NotImplementedException();
}
else
{
if (targetObjectNode.Type.IsUnknown)
{
throw new Exception("Unknown type " + targetObjectNode.Type.Name + " found.");
}
ctor = new CodeObjectCreateExpression(targetObjectNode.Type.UnderlyingType.Name);
}
if (!isPublicObject)
{
CodeVariableDeclarationStatement cvds = new CodeVariableDeclarationStatement(targetObjectNode.Type.UnderlyingType.Name, targetName, ctor);
initComponentMethod.Statements.Add(cvds);
}
else
{
CodeAssignStatement cas = new CodeAssignStatement(new CodeVariableReferenceExpression(targetName), ctor);
initComponentMethod.Statements.Add(cas);
// Needs to be public
PublicObjects.Add(targetName, targetObjectNode);
}
CodeVariableReferenceExpression cvre = new CodeVariableReferenceExpression(targetName);
bool isUsuable = GetIsUsableDuringInitialization(targetObjectNode.Type);
if (isUsuable)
{
GenerateMemberAssignmentWithProvideValueIfNecessary(initComponentMethod, parentExpression, targetObjectNode, parentMember, cvre);
}
AddMembers(initComponentMethod, cvre, targetObjectNode);
if (!isUsuable)
{
GenerateMemberAssignmentWithProvideValueIfNecessary(initComponentMethod, parentExpression, targetObjectNode, parentMember, cvre);
}
}
void BuildWhere(MemberNode leftMember, MemberNode rightMember, ExpressionType op)
{
this.AddCondition(GetFieldName(leftMember.TableName, leftMember.FieldName), _operations[op], GetFieldName(rightMember.TableName, rightMember.FieldName));
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
ToolStripMenuItem item;
TextEditorControl textEditorControl = (TextEditorControl)owner;
if (textEditorControl.FileName == null)
{
return(new ToolStripItem[0]);
}
List <ToolStripItem> resultItems = new List <ToolStripItem>();
TextArea textArea = textEditorControl.ActiveTextAreaControl.TextArea;
IDocument doc = textArea.Document;
int caretLine = textArea.Caret.Line;
// list of dotnet names that have definition bookmarks in this line
List <string> definitions = new List <string>();
// Include definitions (use the bookmarks which should already be present)
// we need to use .ToArray() because the bookmarks might change during enumeration:
// building member/class submenus can cause reparsing the current file, which might change
// the available bookmarks
foreach (Bookmark mark in doc.BookmarkManager.Marks.ToArray())
{
if (mark != null && mark.LineNumber == caretLine)
{
ClassMemberBookmark cmb = mark as ClassMemberBookmark;
ClassBookmark cb = mark as ClassBookmark;
IClass type = null;
if (cmb != null)
{
definitions.Add(cmb.Member.DotNetName);
item = new ToolStripMenuItem(MemberNode.GetText(cmb.Member),
ClassBrowserIconService.ImageList.Images[cmb.IconIndex]);
MenuService.AddItemsToMenu(item.DropDown.Items, mark, ClassMemberBookmark.ContextMenuPath);
resultItems.Add(item);
type = cmb.Member.DeclaringType;
}
else if (cb != null)
{
type = cb.Class;
}
if (type != null)
{
definitions.Add(type.DotNetName);
item = new ToolStripMenuItem(ClassNode.GetText(type), ClassBrowserIconService.ImageList.Images[ClassBrowserIconService.GetIcon(type)]);
MenuService.AddItemsToMenu(item.DropDown.Items,
cb ?? new ClassBookmark(textArea.Document, type),
ClassBookmark.ContextMenuPath);
resultItems.Add(item);
}
}
}
// Include menu for member that has been clicked on
IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(textEditorControl.FileName);
ExpressionResult expressionResult;
ResolveResult rr;
int insertIndex = resultItems.Count; // Insert items at this position to get the outermost expression first, followed by the inner expressions (if any).
expressionResult = FindFullExpressionAtCaret(textArea, expressionFinder);
repeatResolve:
rr = ResolveExpressionAtCaret(textArea, expressionResult);
RefactoringMenuContext context = new RefactoringMenuContext {
TextArea = textArea,
ResolveResult = rr,
ExpressionResult = expressionResult
};
item = null;
if (rr is MethodGroupResolveResult)
{
item = MakeItem(definitions, ((MethodGroupResolveResult)rr).GetMethodIfSingleOverload());
}
else if (rr is MemberResolveResult)
{
MemberResolveResult mrr = (MemberResolveResult)rr;
item = MakeItem(definitions, mrr.ResolvedMember);
if (RefactoringService.FixIndexerExpression(expressionFinder, ref expressionResult, mrr))
{
if (item != null)
{
resultItems.Insert(insertIndex, item);
}
// Include menu for the underlying expression of the
// indexer expression as well.
goto repeatResolve;
}
}
else if (rr is TypeResolveResult)
{
item = MakeItem(definitions, ((TypeResolveResult)rr).ResolvedClass);
}
else if (rr is LocalResolveResult)
{
context.IsDefinition = caretLine + 1 == ((LocalResolveResult)rr).VariableDefinitionRegion.BeginLine;
item = MakeItem((LocalResolveResult)rr, context);
insertIndex = 0; // Insert local variable menu item at the topmost position.
}
else if (rr is UnknownIdentifierResolveResult)
{
item = MakeItemForResolveError((UnknownIdentifierResolveResult)rr, expressionResult.Context, textArea);
insertIndex = 0; // Insert menu item at the topmost position.
}
else if (rr is UnknownConstructorCallResolveResult)
{
item = MakeItemForResolveError((UnknownConstructorCallResolveResult)rr, expressionResult.Context, textArea);
insertIndex = 0; // Insert menu item at the topmost position.
}
if (item != null)
{
resultItems.Insert(insertIndex, item);
}
// Include menu for current class and method
ICompilationUnit cu = null;
IMember callingMember = null;
if (rr != null && rr.CallingMember != null)
{
callingMember = rr.CallingMember;
}
else
{
ParseInformation parseInfo = ParserService.GetParseInformation(textEditorControl.FileName);
if (parseInfo != null)
{
cu = parseInfo.MostRecentCompilationUnit;
if (cu != null)
{
IClass callingClass = cu.GetInnermostClass(caretLine + 1, textArea.Caret.Column + 1);
callingMember = GetCallingMember(callingClass, caretLine + 1, textArea.Caret.Column + 1);
}
}
}
if (callingMember != null)
{
item = MakeItem(definitions, callingMember);
if (item != null)
{
item.Text = StringParser.Parse("${res:SharpDevelop.Refactoring.CurrentMethod}: ") + callingMember.Name;
resultItems.Add(item);
}
}
if (resultItems.Count == 0)
{
return(new ToolStripItem[0]);
}
else
{
resultItems.Add(new MenuSeparator());
return(resultItems.ToArray());
}
}
void BuildSql(MemberNode leftMember, MemberNode rightMember, ExpressionType op)
{
Builder.QueryByFieldComparison(leftMember.TableName, leftMember.FieldName, _operationDictionary[op], rightMember.TableName, rightMember.FieldName);
}
public void AddMember(MemberNode member)
{
}
public LikeNode(LikeMethod method, MemberNode memberNode, string value)
{
Method = method;
MemberNode = memberNode;
Value = value;
}
private void BuildSql(MemberNode leftMember, MemberNode rightMember, ExpressionType operatorType)
{
QueryByFieldComparison(leftMember.TableName, leftMember.FieldName, operationDictionary[operatorType],
rightMember.TableName, rightMember.FieldName);
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
MenuCommand cmd;
IMember member;
MemberNode memberNode = owner as MemberNode;
if (memberNode != null)
{
member = memberNode.Member;
}
else
{
ClassMemberBookmark bookmark = (ClassMemberBookmark)owner;
member = bookmark.Member;
}
IMethod method = member as IMethod;
List <ToolStripItem> list = new List <ToolStripItem>();
bool canGenerateCode =
member.DeclaringType.ProjectContent.Language.CodeGenerator != null &&
!FindReferencesAndRenameHelper.IsReadOnly(member.DeclaringType);
if (method == null || !method.IsConstructor)
{
if (!FindReferencesAndRenameHelper.IsReadOnly(member.DeclaringType) &&
!(member is IProperty && ((IProperty)member).IsIndexer))
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.RenameCommand}", Rename);
cmd.Tag = member;
list.Add(cmd);
}
}
if (member.IsOverride)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.GoToBaseClassCommand}", GoToBase);
cmd.Tag = member;
list.Add(cmd);
}
if (member.IsVirtual || member.IsAbstract || (member.IsOverride && !member.DeclaringType.IsSealed))
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.FindOverridesCommand}", FindOverrides);
cmd.Tag = member;
list.Add(cmd);
}
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.FindReferencesCommand}", FindReferences);
cmd.Tag = member;
list.Add(cmd);
if (member is IField && member.DeclaringType.ClassType != ClassType.Enum)
{
IProperty foundProperty = FindReferencesAndRenameHelper.FindProperty(member as IField);
if (foundProperty != null)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.GoToProperty}", GotoTagMember);
cmd.Tag = foundProperty;
list.Add(cmd);
}
else
{
if (canGenerateCode)
{
if (member.IsReadonly)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateProperty}", CreateGetter);
cmd.Tag = member;
list.Add(cmd);
}
else
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateGetter}", CreateGetter);
cmd.Tag = member;
list.Add(cmd);
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateProperty}", CreateProperty);
cmd.Tag = member;
list.Add(cmd);
}
}
}
}
if (member is IProperty)
{
if (((IProperty)member).CanSet && canGenerateCode)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateChangedEvent}", CreateChangedEvent);
cmd.Tag = member;
list.Add(cmd);
}
}
if (member is IEvent)
{
if (canGenerateCode)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateOnEventMethod}", CreateOnEventMethod);
cmd.Tag = member;
list.Add(cmd);
}
}
return(list.ToArray());
}
private void BuildSql(ValueNode valueNode, MemberNode memberNode, ExpressionType op)
{
BuildSql(memberNode, valueNode, op);
}
private void GenerateMemberValue(CodeMemberMethod initComponentMethod,
MemberNode member, CodeExpression targetExpression)
{
if (member.Member.IsUnknown)
{
//throw new Exception("Unknown member " + member.Member.Name);
return;
}
if (member.Member == XamlLanguage.Class ||
member.Member == XamlLanguage.Initialization ||
member.Member == XamlLanguage.PositionalParameters ||
member.Member == XamlLanguage.Arguments ||
member.Member == XamlLanguage.FactoryMethod)
{
return;
}
else
{
foreach (ItemNode itemNode in member.ItemNodes)
{
ValueNode valueNode = itemNode as ValueNode;
if (valueNode != null)
{
string value = valueNode.Value as String;
if (value != null)
{
if (member.Member.IsUnknown)
{
throw new Exception("Code can not be generated for unknown member: " + member.Member.Name);
}
bool shouldConvert = ShouldUseTypeConverter(value, member.Member.Type.UnderlyingType);
if (shouldConvert)
{
string tcName = GenerateTypeConverter(initComponentMethod, member.Member.Type); //TextSyntax
GenerateMemberAssignment(initComponentMethod,
member,
targetExpression,
GetTypeConverteredValue(member.Member.Type, value, member.Member.Type.UnderlyingType, tcName),
null);
}
else
{
GenerateMemberAssignment(initComponentMethod,
member,
targetExpression,
GenerateExpressionForString(value, member.Member.Type.UnderlyingType),
null);
}
}
else
{
//We shouldn't have this happen. XXR should only give us real numbers.
throw new NotImplementedException();
}
}
else
{
ProcessItemNode(itemNode, initComponentMethod, member, targetExpression);
}
}
}
}
private void BuildJoin(ValueNode valueNode, MemberNode node, ExpressionType op)
{
BuildJoin(node, valueNode, op);
}
private void ProcessItemNode(ItemNode itemNode, CodeMemberMethod initComponentMethod,
MemberNode member, CodeExpression targetExpression)
{
CodeDomObjectNode objectNode = (CodeDomObjectNode)itemNode;
XamlType xamlType = objectNode.Type;
if (xamlType == XamlLanguage.Static)
{
//TODO: this could be posParams or named params...
ValueNode valueNode2 = objectNode.XPosParamsNode.ItemNodes[0] as ValueNode;
string xamlTypeReference = valueNode2.Value as string;
string memberName = null;
string typeName = null;
int period = xamlTypeReference.IndexOf('.');
if (period > -1)
{
memberName = xamlTypeReference.Substring(period + 1);
typeName = xamlTypeReference.Substring(0, period);
}
Type resolvedType = objectNode.Resolve(typeName);
//TODO: don't forget to make sure a using happens for the referencedXamlType
string typeName2 = resolvedType != null ? resolvedType.Name : xamlTypeReference;
//CodeTypeReference ctr = new CodeTypeReference(typeName2);
CodeTypeReferenceExpression ctre = new CodeTypeReferenceExpression(typeName2);
CodePropertyReferenceExpression cpre =
new CodePropertyReferenceExpression(ctre, memberName);
GenerateMemberAssignment(initComponentMethod,
member, targetExpression, cpre, objectNode);
}
else if (xamlType == XamlLanguage.Null)
{
CodePrimitiveExpression nullExpression = new CodePrimitiveExpression(null);
GenerateMemberAssignment(initComponentMethod,
member, targetExpression, nullExpression, objectNode);
}
else if (xamlType == XamlLanguage.Type)
{
//TODO: this could be posParams or named params...
ValueNode valueNode2 = objectNode.XPosParamsNode.ItemNodes[0] as ValueNode;
string xamlTypeReference = valueNode2.Value as string;
Type resolvedType = objectNode.Resolve(xamlTypeReference);
//TODO: don't forget to make sure a using happens for the referencedXamlType
string typeName = resolvedType != null ? resolvedType.Name : xamlTypeReference;
CodeTypeReference ctr = new CodeTypeReference(typeName);
CodeTypeOfExpression typeof1 = new CodeTypeOfExpression(ctr);
GenerateMemberAssignment(initComponentMethod,
member, targetExpression, typeof1, objectNode);
}
else if (xamlType == XamlLanguage.Reference)
{
}
else
{
// We have something other than a ValueNode. Must be a StartObject or GetObject
initComponentMethod.Statements.Add(new CodeCommentStatement("---------------------------"));
if (objectNode.Type != null)
{
// Handle special case for Bindings
if (objectNode.Type.Name == "Binding")
{
GenerateBindingObject(initComponentMethod, targetExpression, objectNode, member);
}
else
{
// StartObject case
GenerateObject(initComponentMethod, targetExpression, objectNode, member);
}
}
else
{
// GetObject
GenerateGetObject(initComponentMethod, targetExpression, objectNode, member);
}
}
}
/// <summary>
/// Add the given message to the log.
/// </summary>
private void Log(MessageTypes type, string member, IMetadataScope scope, string msg)
{
if (IsDisposed) return;
if (InvokeRequired)
{
Invoke(new Action<MessageTypes, string, IMetadataScope, string>(Log), type, member, scope, msg);
}
else
{
if ((type >= MessageTypes.MissingFirst) && (type <= MessageTypes.MissingLast))
{
MemberNode node;
if (!nodes.TryGetValue(member, out node))
{
node = new MemberNode(member, scope, type);
node.ImageIndex = (int) type;
nodes.Add(member, node);
tvList.Nodes.Add(node);
}
node.Messages.Add(msg);
if (node == tvList.SelectedNode)
{
tvUsedIn.Nodes.Add(new TreeNode(msg));
}
}
else
{
tvLog.Nodes.Add(new TreeNode(msg) { ImageIndex = (int) type });
}
miCopy.Enabled = (tvList.Nodes.Count > 0);
}
}
private void CreateSearchNodes()
{
// "flat" structure
root = new SymbolNode("Test template", "", "testTemplace.zzz", 0, 0, SymbolNode.LibraryNodeType.Hierarchy);
namespaceNode = new NamespaceNode("ClassLibrary1", "", "Class1.cs", 7, 0);
classNode = new ModelNode("Class1", "ClassLibrary1.", "Class1.cs", 7, 17);
memberNode = new MemberNode("GetBlaBlaBla", "ClassLibrary1.Class1.", "Class1.cs", 9, 22);
ModelReferenceList
classReferenceNode = new ModelReferenceList(
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class1.cs - (8, 18) : public class Class1(NDjango symbol)",
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class1.cs",
"", 8, 18),
classReferenceNode1 = new ModelReferenceList(
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class2.cs - (7, 13) : Class1 c1 = new Class1();(NDjango symbol)",
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class2.cs",
"", 7, 13);
classNode.AddChild(classReferenceNode);
classNode.AddChild(classReferenceNode1);
MemberReferenceList
methodReferenceNode = new MemberReferenceList(
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class1.cs - (10, 23) : public Class1 GetBlaBlaBla()(NDjango symbol)",
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class1.cs",
"", 10, 23),
methodReferenceNode1 = new MemberReferenceList(
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class1.cs - (0, 0) : public Class1 GetBlaBlaBla()(NDjango symbol)",
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class1.cs",
"", 0, 0),
methodReferenceNode2 = new MemberReferenceList(
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class1.cs - (0, 0) : public Class1 GetBlaBlaBla()(NDjango symbol)",
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class1.cs",
"", 0, 0);
memberNode.AddChild(methodReferenceNode);
memberNode.AddChild(methodReferenceNode1);
memberNode.AddChild(methodReferenceNode2);
NamespaceReferenceList
nsl1 = new NamespaceReferenceList(
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class1.cs - (2, 2) (NDjango symbol)",
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class1.cs",
"", 0, 0),
nsl2 = new NamespaceReferenceList(
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class2.cs - (3, 3) (NDjango symbol)",
@"C:\Users\sivanov\Documents\Visual Studio 2010\Projects\ClassLibrary1\ClassLibrary1\Class2.cs",
"", 0, 0);
namespaceNode.AddChild(nsl1);
namespaceNode.AddChild(nsl2);
root.AddChild(memberNode);
root.AddChild(classNode);
root.AddChild(namespaceNode);
}
