public static string GeneratePrototype(DVariable dv)
{
var sb = new StringBuilder("Variable in ");
sb.Append(AbstractNode.GetNodePath(dv, false));
sb.Append(": ");
sb.Append(dv.ToString(false));
return(sb.ToString());
}
public static string GeneratePrototype(TemplateIntermediateType tit, int currentParam = -1)
{
var sb = new StringBuilder("");
if (tit is ClassType)
{
sb.Append("Class");
}
else if (tit is InterfaceType)
{
sb.Append("Interface");
}
else if (tit is TemplateType)
{
sb.Append("Template");
}
else if (tit is StructType)
{
sb.Append("Struct");
}
else if (tit is UnionType)
{
sb.Append("Union");
}
var dc = tit.Definition;
sb.Append(" in ");
sb.Append(AbstractNode.GetNodePath(dc, false));
sb.Append(": ").Append(tit.Name);
if (dc.TemplateParameters != null && dc.TemplateParameters.Length != 0)
{
sb.Append('(');
for (int i = 0; i < dc.TemplateParameters.Length; i++)
{
sb.Append(dc.TemplateParameters[i].ToString());
sb.Append(',');
}
sb.Remove(sb.Length - 1, 1).Append(')');
}
return(sb.ToString());
}
public static AbstractType TryDeduce(DSymbol t, IEnumerable <ISemantic> templateArguments, out bool supersedeOtherOverloads)
{
var def = t.Definition;
IHook hook;
if (def != null && DeductionHooks.TryGetValue(AbstractNode.GetNodePath(def, true), out hook))
{
supersedeOtherOverloads = hook.SupersedesMultipleOverloads;
INode n = null;
var res = hook.TryDeduce(t, templateArguments, ref n);
if (n != null)
{
resultStore.Add(res, n);
}
return(res);
}
supersedeOtherOverloads = true;
return(null);
}
protected override void Update(CommandArrayInfo info)
{
if (caps.Update())
{
if (caps.resultResolutionAttempt != LooseResolution.NodeResolutionAttempt.RawSymbolLookup)
{
var refactoringMenu = new CommandInfoSet {
Text = GettextCatalog.GetString("Refactoring")
};
if (caps.lastResults.Any(t => t is DSymbol && DRenameRefactoring.CanRenameNode((t as DSymbol).Definition)))
{
refactoringMenu.CommandInfos.Add(IdeApp.CommandService.GetCommandInfo(EditCommands.Rename), new Action(caps.RenameSymbol));
}
if (refactoringMenu.CommandInfos.Count > 0)
{
info.Add(refactoringMenu);
}
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.GotoDeclaration), new Action(caps.GotoDeclaration));
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindReferences), new Action(() => caps.FindReferences(false)));
if (caps.lastResults.Any(t => t is DSymbol && (t as DSymbol).Definition.Parent is DClassLike))
{
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindAllReferences), new Action(() => caps.FindReferences(true)));
}
if (caps.lastResults.Any(t => {
var ds = DResolver.StripMemberSymbols(t);
return(ds is ClassType || ds is InterfaceType);
}))
{
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindDerivedClasses), new Action(caps.FindDerivedClasses));
}
}
else
{
var importSymbolMenu = new CommandInfoSet {
Text = GettextCatalog.GetString("Resolve")
};
foreach (var m in caps.GetImportableModulesForLastResults())
{
importSymbolMenu.CommandInfos.Add(new CommandInfo {
Text = "import " + AbstractNode.GetNodePath(m, true) + ";",
Icon = MonoDevelop.Ide.Gui.Stock.AddNamespace
}, new object[] { RefactoryCommands.ImportSymbol, m });
}
if (importSymbolMenu.CommandInfos.Count > 0)
{
importSymbolMenu.CommandInfos.AddSeparator();
var alreadyAddedItems = new List <DModule> ();
foreach (var t in caps.lastResults)
{
var n = DResolver.GetResultMember(t, true);
if (n == null)
{
continue;
}
var m = n.NodeRoot as DModule;
if (m != null && !alreadyAddedItems.Contains(m))
{
alreadyAddedItems.Add(m);
importSymbolMenu.CommandInfos.Add(new CommandInfo {
Text = AbstractNode.GetNodePath(n, true)
}, new object[] { RefactoryCommands.QuickFix, n });
}
}
// To explicitly show the Ctrl+Alt+Space hint.
importSymbolMenu.CommandInfos.AddSeparator();
importSymbolMenu.CommandInfos.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.ImportSymbol), new Action(caps.TryImportMissingSymbol));
info.Add(importSymbolMenu);
}
}
}
if (SortImportsCommandHandler.CanSortImports(caps.lastDoc))
{
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.SortImports), new Action(() => SortImportsCommandHandler.SortImports(caps.lastDoc)));
}
}
public static string GeneratePrototype(DMethod dm, bool isTemplateParamInsight = false, int currentParam = -1)
{
var sb = new StringBuilder("");
string name;
switch (dm.SpecialType)
{
case DMethod.MethodType.Constructor:
sb.Append("Constructor");
name = dm.Parent.Name;
break;
case DMethod.MethodType.Destructor:
sb.Append("Destructor");
name = dm.Parent.Name;
break;
case DMethod.MethodType.Allocator:
sb.Append("Allocator");
name = dm.Parent.Name;
break;
default:
sb.Append("Method");
name = dm.Name;
break;
}
sb.Append(" in ");
sb.Append(AbstractNode.GetNodePath(dm, false));
sb.Append(": ");
if (dm.Attributes != null && dm.Attributes.Count > 0)
{
sb.Append(dm.AttributeString + ' ');
}
if (dm.Type != null)
{
sb.Append(dm.Type.ToString(true));
sb.Append(" ");
}
else if (dm.Attributes != null && dm.Attributes.Count != 0)
{
foreach (var attr in dm.Attributes)
{
var m = attr as Modifier;
if (m != null && DTokens.StorageClass[m.Token])
{
sb.Append(DTokens.GetTokenString(m.Token));
sb.Append(" ");
break;
}
}
}
sb.Append(name);
// Template parameters
if (dm.TemplateParameters != null && dm.TemplateParameters.Length > 0)
{
sb.Append("(");
for (int i = 0; i < dm.TemplateParameters.Length; i++)
{
var p = dm.TemplateParameters[i];
if (isTemplateParamInsight && i == currentParam)
{
sb.Append(p.ToString());
}
else
{
sb.Append(p.ToString());
}
if (i < dm.TemplateParameters.Length - 1)
{
sb.Append(",");
}
}
sb.Append(")");
}
// Parameters
sb.Append("(");
for (int i = 0; i < dm.Parameters.Count; i++)
{
var p = dm.Parameters[i] as DNode;
if (!isTemplateParamInsight && i == currentParam)
{
sb.Append(p.ToString(true, false));
}
else
{
sb.Append(p.ToString(true, false));
}
if (i < dm.Parameters.Count - 1)
{
sb.Append(",");
}
}
sb.Append(")");
return(sb.ToString());
}