internal static CompletionData ConvertMirrorToCompletionData(StaticMirror mirror, bool useShorterName = false,
ElementResolver resolver = null)
{
var method = mirror as MethodMirror;
if (method != null)
{
string methodName = method.MethodName;
string signature = method.ToString();
CompletionType type = method.IsConstructor ? CompletionType.Constructor : CompletionType.Method;
return(new CompletionData(methodName, type, signature));
}
var property = mirror as PropertyMirror;
if (property != null)
{
string propertyName = property.PropertyName;
return(new CompletionData(propertyName, CompletionType.Property, property.ToString()));
}
var classMirror = mirror as ClassMirror;
if (classMirror != null)
{
string className = useShorterName ? GetShortClassName(classMirror, resolver) : classMirror.Alias;
return(new CompletionData(className, CompletionType.Class));
}
throw new ArgumentException("Invalid argument");
}
internal static CompletionData ConvertMirrorToCompletionData(StaticMirror mirror, bool useFullyQualifiedName = false)
{
MethodMirror method = mirror as MethodMirror;
if (method != null)
{
string methodName = method.MethodName;
string signature = method.ToString();
CompletionType type = method.IsConstructor ? CompletionType.Constructor : CompletionType.Method;
return(new CompletionData(methodName, type)
{
Stub = signature
});
}
PropertyMirror property = mirror as PropertyMirror;
if (property != null)
{
string propertyName = property.PropertyName;
return(new CompletionData(propertyName, CompletionType.Property));
}
ClassMirror classMirror = mirror as ClassMirror;
if (classMirror != null)
{
string className = useFullyQualifiedName ? classMirror.ClassName : classMirror.Alias;
return(new CompletionData(className, CompletionType.Class));
}
else
{
throw new ArgumentException("Invalid argument");
}
}
public void TestGetAllTypesContainPrimitiveType()
{
var types = StaticMirror.GetAllTypes(core);
Assert.IsTrue(types.Any(cm => cm.ClassName.Equals("int")));
Assert.IsTrue(types.Any(cm => cm.ClassName.Equals("double")));
}
/// <summary>
/// Matches the completion string with classes, including primitive types.
/// </summary>
/// <param name="stringToComplete"></param>
/// <returns></returns>
internal IEnumerable <CompletionData> SearchTypes(string stringToComplete)
{
var completions = new List <CompletionData>();
var partialName = stringToComplete.ToLower();
// Add matching Classes
var classMirrorGroups =
StaticMirror.GetAllTypes(core)
.Where(x => !x.IsHiddenInLibrary && x.Alias.ToLower().StartsWith(partialName))
.GroupBy(x => x.Alias);
// For those class names that have collisions (same alias), list
// their fully qualified names in completion window.
foreach (var classMirrorGroup in classMirrorGroups)
{
bool useFullyQualifiedName = classMirrorGroup.Count() > 1;
foreach (var classMirror in classMirrorGroup)
{
var completionData = CompletionData.ConvertMirrorToCompletionData(classMirror, useFullyQualifiedName);
completions.Add(completionData);
}
}
return(completions);
}
private void AddTypesToCompletionData(string stringToComplete, List <CompletionData> completions, ElementResolver resolver)
{
var partialName = stringToComplete.ToLower();
// Add matching Classes
var classMirrorGroups = StaticMirror.GetAllTypes(core).
Where(x => !x.IsHiddenInLibrary && x.Alias.ToLower().Contains(partialName)).
GroupBy(x => x.Alias);
foreach (var classMirrorGroup in classMirrorGroups)
{
// For those class names that have collisions, use shorter names
bool useShorterName = classMirrorGroup.Count() > 1;
if (useShorterName)
{
// For colliding namespaces, compute shortest unique names for each
var namespaces = classMirrorGroup.Select(x => new Symbol(x.ClassName)).ToList();
var shortNames = Symbol.GetShortestUniqueNames(namespaces);
Debug.Assert(shortNames.Count() == classMirrorGroup.Count());
// Update class mirror (group) Alias with short name computed above
for (int i = 0; i < classMirrorGroup.Count(); i++)
{
var cm = classMirrorGroup.ElementAt(i);
cm.Alias = shortNames.ElementAt(i).Value;
}
}
completions.AddRange(classMirrorGroup.
Where(x => !x.IsEmpty).
Select(x =>
CompletionData.ConvertMirrorToCompletionData(x, useShorterName,
resolver: resolver)));
}
}
public MethodMirror GetDeclaredMethod(string methodName, List <ProtoCore.Type> argumentTypes)
{
ProcedureTable procedureTable = ClassNode.vtable;
List <ProcedureNode> procList = procedureTable.procList;
return(StaticMirror.FindMethod(methodName, argumentTypes, procList));
}
public MethodMirror GetDeclaredMethod(string className, string methodName, List <ProtoCore.Type> argumentTypes)
{
// Check global methods if classname is empty or null
if (string.IsNullOrEmpty(className))
{
List <MethodMirror> methods = null;
methods = GetGlobalMethods();
foreach (var method in methods)
{
if (method.MethodName == methodName)
{
List <ProtoCore.Type> argTypes = method.GetArgumentTypes();
if (argTypes.Count == argumentTypes.Count)
{
bool isEqual = true;
for (int i = 0; i < argumentTypes.Count; ++i)
{
if (!argumentTypes[i].Equals(argTypes[i]))
{
isEqual = false;
break;
}
}
if (isEqual)
{
return(method);
}
}
}
}
}
else // find method in Class
{
Validity.Assert(staticCore != null);
ClassNode classNode = null;
ProtoCore.DSASM.ClassTable classTable = staticCore.ClassTable;
int ci = classTable.IndexOf(className);
if (ci != ProtoCore.DSASM.Constants.kInvalidIndex)
{
classNode = classTable.ClassNodes[ci];
}
ProcedureTable procedureTable = classNode.vtable;
List <ProcedureNode> procList = procedureTable.procList;
return(StaticMirror.FindMethod(methodName, argumentTypes, procList));
}
return(null);
}
public LibraryItem(NodeType type, string qualifiedName)
{
this.qualifiedName = qualifiedName;
UpdateDisplayText();
this.dataMirror = null;
Level = -1;
Type = MemberType.None;
ItemType = type;
Assembly = String.Empty;
ArgumentTypes = String.Empty;
ArgumentNames = String.Empty;
IsOverloaded = false;
IsExternal = false;
}
public LibraryItem(NodeType type, string qualifiedName)
{
this.qualifiedName = qualifiedName;
UpdateDisplayText();
this.dataMirror = null;
Level = -1;
Type = MemberType.None;
ItemType = type;
Assembly = String.Empty;
ArgumentTypes = String.Empty;
ArgumentNames = String.Empty;
IsOverloaded = false;
IsExternal = false;
}
public LibraryItem()
{
this.qualifiedName = String.Empty;
this.dataMirror = null;
Level = -1;
Type = MemberType.None;
ItemType = NodeType.None;
DisplayText = String.Empty;
Assembly = String.Empty;
ArgumentTypes = String.Empty;
ArgumentNames = String.Empty;
IsOverloaded = false;
IsExternal = false;
}
public LibraryItem()
{
this.qualifiedName = String.Empty;
this.dataMirror = null;
Level = -1;
Type = MemberType.None;
ItemType = NodeType.None;
DisplayText = String.Empty;
Assembly = String.Empty;
ArgumentTypes = String.Empty;
ArgumentNames = String.Empty;
IsOverloaded = false;
IsExternal = false;
}
/// <summary>
/// Returns the list of function signatures of all overloads of a given method
/// </summary>
/// <param name="code"> code being typed in code block </param>
/// <param name="functionName"> given method name for which signature is queried </param>
/// <param name="functionPrefix"> class name in case of constructor or static method, OR
/// declared instance variable on which method is invoked </param>
/// <param name="resolver"></param>
/// <returns> list of method overload signatures </returns>
internal IEnumerable <CompletionData> GetFunctionSignatures(string code, string functionName, string functionPrefix,
ElementResolver resolver = null)
{
IEnumerable <MethodMirror> candidates = null;
// if function is global, search for function in Built-ins
if (string.IsNullOrEmpty(functionPrefix))
{
return(StaticMirror.GetOverloadsOnBuiltIns(core, functionName).
Select(x =>
{
return new CompletionData(x.MethodName, CompletionData.CompletionType.Method)
{
Stub = x.ToString()
};
}));
}
// Determine if the function prefix is a class name
if (resolver != null)
{
functionPrefix = resolver.LookupResolvedName(functionPrefix) ?? functionPrefix;
}
var type = GetClassType(functionPrefix);
if (type != null)
{
candidates = type.GetOverloadsOnType(functionName);
}
// If not of class type
else
{
// Check if the function prefix is a typed identifier
string typeName = CodeCompletionParser.GetVariableType(code, functionPrefix);
if (typeName != null)
{
type = GetClassType(typeName);
}
if (type != null)
{
candidates = type.GetOverloadsOnInstance(functionName);
}
}
return(candidates.Select(x => CompletionData.ConvertMirrorToCompletionData(x)));
}
/// <summary>
/// Matches the completion string with classes and
/// global methods and properties loaded in the session
/// </summary>
/// <param name="stringToComplete"> current string being typed which is to be completed </param>
/// <param name="guid"> code block node guid to identify current node being typed </param>
/// <param name="resolver"></param>
/// <returns> list of classes, global methods and properties that match with string being completed </returns>
internal IEnumerable <CompletionData> SearchCompletions(string stringToComplete, Guid guid, ElementResolver resolver = null)
{
var completions = new List <CompletionData>();
// Add matching DS keywords
completions.AddRange(KeywordList.Where(x => x.ToLower().Contains(stringToComplete.ToLower())).
Select(x => new CompletionData(x, CompletionData.CompletionType.Keyword)));
AddTypesToCompletionData(stringToComplete, completions, resolver);
// Add matching builtin methods
completions.AddRange(StaticMirror.GetBuiltInMethods(core).
GroupBy(x => x.Name).Select(y => y.First()).
Where(x => x.MethodName.ToLower().Contains(stringToComplete.ToLower())).
Select(x => CompletionData.ConvertMirrorToCompletionData(x)));
return(completions);
}
public MethodMirror GetDeclaredMethod(string methodName, List <ProtoCore.Type> argumentTypes)
{
if (classNode == null)
{
Validity.Assert(staticCore != null);
ProtoCore.DSASM.ClassTable classTable = staticCore.ClassTable;
int ci = classTable.IndexOf(ClassName);
if (ci != ProtoCore.DSASM.Constants.kInvalidIndex)
{
classNode = classTable.ClassNodes[ci];
}
}
ProcedureTable procedureTable = classNode.vtable;
List <ProcedureNode> procList = procedureTable.procList;
return(StaticMirror.FindMethod(methodName, argumentTypes, procList));
}
/// <summary>
/// Matches the completion string with classes and
/// global methods and properties loaded in the session
/// </summary>
/// <param name="stringToComplete"> current string being typed which is to be completed </param>
/// <param name="guid"> code block node guid to identify current node being typed </param>
/// <returns> list of classes, global methods and properties that match with string being completed </returns>
internal IEnumerable <CompletionData> SearchCompletions(string stringToComplete, Guid guid)
{
List <CompletionData> completions = new List <CompletionData>();
// Add matching DS keywords
completions.AddRange(KeywordList.Where(x => x.ToLower().Contains(stringToComplete.ToLower())).
Select(x => new CompletionData(x, CompletionData.CompletionType.Keyword)));
// Add matching Classes
var groups = StaticMirror.GetClasses(core).
Where(x => x.Alias.ToLower().Contains(stringToComplete.ToLower())).
GroupBy(x => x.Alias);
// For those class names that have collisions, list their fully qualified names in completion window
foreach (var group in groups)
{
if (group.Count() > 1)
{
completions.AddRange(group.
Where(x => !x.IsHiddenInLibrary).
Select(x => CompletionData.ConvertMirrorToCompletionData(x, useFullyQualifiedName: true)));
}
else
{
completions.AddRange(group.
Where(x => !x.IsHiddenInLibrary).
Select(x => CompletionData.ConvertMirrorToCompletionData(x)));
}
}
// Add matching builtin methods
completions.AddRange(StaticMirror.GetBuiltInMethods(core).
GroupBy(x => x.Name).Select(y => y.First()).
Where(x => x.MethodName.ToLower().Contains(stringToComplete.ToLower())).
Select(x => CompletionData.ConvertMirrorToCompletionData(x)));
return(completions);
}
/// <summary>
/// Returns the list of names of global methods and properties in Core
/// </summary>
/// <returns> list of names of global methods and properties </returns>
internal IEnumerable <string> GetGlobals()
{
return(StaticMirror.GetGlobals(core).Select(x => x.Name));
}
/// <summary>
/// Returns the list of names of classes loaded in the Core
/// </summary>
/// <returns> list of class names </returns>
internal IEnumerable <string> GetClasses()
{
return(StaticMirror.GetClasses(core).Select(x => x.Alias));
}
internal static CompletionData ConvertMirrorToCompletionData(StaticMirror mirror, bool useShorterName = false,
ElementResolver resolver = null)
{
var method = mirror as MethodMirror;
if (method != null)
{
string methodName = method.MethodName;
string signature = method.ToString();
CompletionType type = method.IsConstructor ? CompletionType.Constructor : CompletionType.Method;
return new CompletionData(methodName, type)
{
Stub = signature
};
}
var property = mirror as PropertyMirror;
if (property != null)
{
string propertyName = property.PropertyName;
return new CompletionData(propertyName, CompletionType.Property);
}
var classMirror = mirror as ClassMirror;
if (classMirror != null)
{
string className = useShorterName ? GetShortClassName(classMirror, resolver) : classMirror.Alias;
return new CompletionData(className, CompletionType.Class);
}
else
throw new ArgumentException("Invalid argument");
}
internal static CompletionData ConvertMirrorToCompletionData(StaticMirror mirror, bool useFullyQualifiedName = false)
{
MethodMirror method = mirror as MethodMirror;
if (method != null)
{
string methodName = method.MethodName;
string signature = method.ToString();
CompletionType type = method.IsConstructor ? CompletionType.Constructor : CompletionType.Method;
return new CompletionData(methodName, type)
{
Stub = signature
};
}
PropertyMirror property = mirror as PropertyMirror;
if (property != null)
{
string propertyName = property.PropertyName;
return new CompletionData(propertyName, CompletionType.Property);
}
ClassMirror classMirror = mirror as ClassMirror;
if (classMirror != null)
{
string className = useFullyQualifiedName ? classMirror.ClassName : classMirror.Alias;
return new CompletionData(className, CompletionType.Class);
}
else
throw new ArgumentException("Invalid argument");
}