/// <summary>
/// Create MethodGenericInstance and connect to the Method, through the Instance edge.
/// Furthermore, added GenericParameter to the MethodGenericInstance.
/// </summary>
/// <param name="symbol">Called method</param>
/// <param name="refersTo">Called method definition</param>
/// <returns>MethodGenericInstance node from the LIM</returns>
public static MethodGenericInstance GetMGI(this ISymbol symbol, IMethodSymbol refersTo)
{
string uName = symbol.ToString();
MethodGenericInstance mgi;
if (MainDeclaration.Instance.MgiMap.TryGetValue(uName, out mgi))
{
return(mgi);
}
mgi = MainDeclaration.Instance.LimFactory.createMethodGenericInstanceNode();
mgi.IsRealInstance = true;
mgi.Name = symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
mgi.MangledName = uName;
mgi.DemangledName = uName;
mgi.Language = Types.LanguageKind.lnkCsharp;
IMethodSymbol roslynNode = symbol as IMethodSymbol;
Base owner = refersTo != null?refersTo.ConvertToLimNode() : symbol.OriginalDefinition.ConvertToLimNode();
if (owner == null)
{
return(null);
}
if (Lim.Asg.Common.getIsMethod(owner))
{
Method ownerMethod = owner as Method;
Commons.Common.Safe_Edge(ownerMethod, "Instance", mgi.Id);
if (roslynNode.Arity > 0)
{
int i = 0;
foreach (var argument in roslynNode.TypeArguments)
{
ITypeSymbol arg = null;
if (!argument.IsInMetadata() && argument.TypeKind != TypeKind.TypeParameter)
{
SyntaxNode _tmp = null;
arg = (INamedTypeSymbol)argument.GetDefinition(out _tmp);
}
Columbus.Lim.Asg.Nodes.Type.Type param = (arg != null) ? arg.GetLimType() : argument.GetLimType();
MainDeclaration.Instance.UsesStack.Peek().Remove(param.Id);
Types.TypeArgumentConstraintKind tack = Types.TypeArgumentConstraintKind.tackUpperBounded;
if (roslynNode.TypeParameters[i].ConstraintTypes.Any())
{
tack = Types.TypeArgumentConstraintKind.tackUnbounded;
}
bool found = false;
ListIteratorAssocTypeArgumentConstraintKind <Columbus.Lim.Asg.Nodes.Type.Type> cIt = mgi.HasArgumentsListIteratorAssocBegin;
while (cIt.getValue() != null)
{
Lim.Asg.Nodes.Type.Type value = cIt.getValue();
if (param.Id == value.Id)
{
found = true;
break;
}
cIt = cIt.getNext();
}
if (!found)
{
mgi.addHasArguments(param, tack);
}
i++;
}
}
}
MainDeclaration.Instance.MgiMap.Add(uName, mgi);
return(mgi);
}
/// <summary>
/// Create ClassGenericInstance and connect to the Class, through the Instance edge.
/// Furthermore, added GenericParameter to the ClassGenericInstance.
/// </summary>
/// <param name="symbol">Instanced class</param>
/// <param name="refersTo">Instanced class definiton</param>
/// <returns>ClassGenericInstnace from the LIM</returns>
public static ClassGenericInstance GetCGI(this ISymbol symbol, INamedTypeSymbol refersTo)
{
string uName = symbol.ToString();
ClassGenericInstance cgi;
if (MainDeclaration.Instance.CgiMap.TryGetValue(uName, out cgi))
{
return(cgi);
}
cgi = MainDeclaration.Instance.LimFactory.createClassGenericInstanceNode();
cgi.IsRealInstance = true;
cgi.Name = symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
cgi.MangledName = uName;
cgi.DemangledName = uName;
cgi.Language = Types.LanguageKind.lnkCsharp;
INamedTypeSymbol roslynNode = symbol as INamedTypeSymbol;
bool isInMeta = false;
if (refersTo == null)
{
refersTo = (INamedTypeSymbol)symbol.OriginalDefinition; isInMeta = true;
}
if (refersTo != null)
{
Base owner = refersTo.ConvertToLimNode();
if (isInMeta)
{
Commons.Common.MetaDataNameFiller(symbol, (Member)owner);
}
if (Lim.Asg.Common.getIsClass(owner))
{
Class ownerClass = owner as Class;
Commons.Common.Safe_Edge(ownerClass, "Instance", cgi.Id);
int i = 0;
foreach (var argument in roslynNode.TypeArguments)
{
ITypeSymbol arg = null;
if (!argument.IsInMetadata() && argument.TypeKind != TypeKind.TypeParameter)
{
SyntaxNode tmp;
arg = (INamedTypeSymbol)argument.GetDefinition(out tmp);
}
Lim.Asg.Nodes.Type.Type param = (arg != null) ? arg.GetLimType() : argument.GetLimType();
MainDeclaration.Instance.UsesStack.Peek().Remove(param.Id);
Types.TypeArgumentConstraintKind tack = Types.TypeArgumentConstraintKind.tackUpperBounded;
if (roslynNode.TypeParameters[i].ConstraintTypes.Length > 0)
{
tack = Types.TypeArgumentConstraintKind.tackUnbounded;
}
bool found = false;
ListIteratorAssocTypeArgumentConstraintKind <Lim.Asg.Nodes.Type.Type> cIt = cgi.HasArgumentsListIteratorAssocBegin;
while (cIt.getValue() != null)
{
Lim.Asg.Nodes.Type.Type value = cIt.getValue();
if (param.Id == value.Id)
{
found = true;
break;
}
cIt = cIt.getNext();
}
if (!found)
{
cgi.addHasArguments(param, tack);
}
i++;
}
}
}
MainDeclaration.Instance.CgiMap.Add(uName, cgi);
return(cgi);
}
public static void fillCollectedMethodData(Method method, MethodInfo methodInfo)
{
method.NestingLevel = (ushort)methodInfo.NL;
method.NestingLevelElseIf = (ushort)methodInfo.NLE;
method.NumberOfBranches = (ushort)methodInfo.NOB;
method.NumberOfStatements = (ushort)methodInfo.NOS;
foreach (KeyValuePair <uint, bool> call in methodInfo.Calls)
{
if (call.Value)
{
MainDeclaration.Instance.LimFactory.setFiltered(call.Key);
}
Commons.Common.Safe_Edge(method, "Calls", call.Key);
}
foreach (KeyValuePair <uint, bool> throws in methodInfo.Throws)
{
if (throws.Value)
{
MainDeclaration.Instance.LimFactory.setFiltered(throws.Key);
}
Commons.Common.Safe_Edge(method, "Throws", throws.Key);
}
foreach (KeyValuePair <uint, bool> canThrows in methodInfo.CanThrow)
{
if (canThrows.Value)
{
MainDeclaration.Instance.LimFactory.setFiltered(canThrows.Key);
}
Commons.Common.Safe_Edge(method, "CanThrow", canThrows.Key);
}
foreach (KeyValuePair <uint, bool> instantiates in methodInfo.Instantiates)
{
if (instantiates.Value)
{
MainDeclaration.Instance.LimFactory.setFiltered(instantiates.Key);
}
Commons.Common.Safe_Edge(method, "Instantiates", instantiates.Key);
}
foreach (KeyValuePair <uint, bool> accessAttribute in methodInfo.AccessAttribute)
{
if (accessAttribute.Value)
{
MainDeclaration.Instance.LimFactory.setFiltered(accessAttribute.Key);
}
Commons.Common.Safe_Edge(method, "AccessesAttribute", accessAttribute.Key);
}
if (!method.ReturnsIsEmpty)
{
Lim.Asg.Nodes.Type.Type returnType = method.ReturnsListIteratorBegin.getValue();
if (returnType != null)
{
MainDeclaration.Instance.UsesStack.Peek().Remove(returnType.Id);
}
}
if (!method.HasParameterIsEmpty)
{
ListIterator <Lim.Asg.Nodes.Logical.Parameter> paramIt = method.HasParameterListIteratorBegin;
while (paramIt.getValue() != null)
{
MainDeclaration.Instance.UsesStack.Peek().Remove(paramIt.getValue().getHasType());
paramIt = paramIt.getNext();
}
}
IEnumerable <uint> _throws = methodInfo.Throws.Select(t => t.Key);
IEnumerable <uint> _canThrows = methodInfo.CanThrow.Select(t => t.Key);
IEnumerable <uint> _instantiates = methodInfo.Instantiates.Select(t => t.Key);
Commons.Common.Remove(ref _throws);
Commons.Common.Remove(ref _canThrows);
Commons.Common.Remove(ref _instantiates);
Commons.Common.AddUses(method);
}
private void fillData(Parameter limNode, IParameterSymbol roslynNode, bool setHasMember)
{
switch (roslynNode.RefKind)
{
case RefKind.None:
limNode.ParamKind = Types.ParameterKind.pmkIn;
break;
case RefKind.Ref:
limNode.ParamKind = Types.ParameterKind.pmkInOut;
break;
case RefKind.Out:
limNode.ParamKind = Types.ParameterKind.pmkOut;
break;
}
if (roslynNode.Type != null)
{
SyntaxNode _m;
Lim.Asg.Nodes.Type.Type type = null;
if (!roslynNode.Type.IsInMetadata())
{
var original = roslynNode.Type.GetDefinition(out _m);
if (original != null && original.Kind == roslynNode.Type.Kind)
{
var namedType = roslynNode.Type as INamedTypeSymbol;
if (namedType != null && namedType.IsGenericType)
{
type = roslynNode.Type.GetLimType(original);
}
else
{
type = original.GetLimType();
}
}
}
else
{
type = roslynNode.Type.GetLimType();
if (roslynNode.Type.TypeKind != TypeKind.Array)
{
MainDeclaration.Instance.LimFactory.setFiltered(type.Id);
}
}
if (type != null)
{
limNode.setHasType(type);
}
}
else
{
limNode.setHasType(Commons.Common.UnknownType);
}
if (MainDeclaration.Instance.MethodStack.Count > 0)
{
//hasParameter
Method parent = (Method)MainDeclaration.Instance.LimFactory.getRef(
MainDeclaration.Instance.MethodStack.Peek().Id
);
Commons.Common.Safe_Edge(parent, "HasParameter", limNode.Id);
}
}
private void fillData(Attribute limNode, IFieldSymbol roslynNode, bool setHasMember)
{
fillMemberData(limNode, roslynNode, setHasMember);
if (MainDeclaration.Instance.ClassStack.Count > 0)
{
Class parnetClass = (Class)MainDeclaration.Instance.LimFactory.getRef(MainDeclaration.Instance.ClassStack.Peek().Id);
if (parnetClass.ClassKind == Types.ClassKind.clkInterface)
{
limNode.Accessibility = Types.AccessibilityKind.ackPublic;
}
}
var roslynType = roslynNode.Type;
if (roslynType != null)
{
if (roslynType is ITypeParameterSymbol)
{
GenericParameter limReturnType = (GenericParameter)roslynType.ConvertToLimNode();
if (limReturnType == null)
{
return;
}
fillData(limReturnType, roslynType as ITypeParameterSymbol, setHasMember);
}
else
{
SyntaxNode syntaxNode = null;
var originalType = roslynType.GetDefinition(out syntaxNode);
Lim.Asg.Nodes.Type.Type limType = null;
if (originalType != null && originalType.Kind == roslynType.Kind)
{
if (((INamedTypeSymbol)originalType).IsGenericType)
{
limType = roslynType.GetLimType(originalType);
}
else
{
limType = originalType.GetLimType();
}
}
else if (roslynType.IsInMetadata())
{
limType = roslynType.GetLimType();
if (roslynType.TypeKind != TypeKind.Array)
{
MainDeclaration.Instance.LimFactory.setFiltered(limType.Id);
}
}
if (limNode.HasTypeIsEmpty)
{
limNode.addHasType(limType);
}
}
}
else
{
limNode.addHasType(Commons.Common.UnknownType);
}
limNode.MangledName += ' ' + roslynType.ToString();
limNode.DemangledName = limNode.MangledName;
}
private void fillData(Method limNode, IMethodSymbol roslynNode, bool setHasMember)
{
MainDeclaration.Instance.MethodStack.Push(new MethodInfo(limNode.Id));
fillScopeData(limNode, roslynNode, setHasMember);
limNode.IsAbstract = roslynNode.IsAbstract;
if (roslynNode.ContainingType != null && roslynNode.ContainingType.TypeKind == TypeKind.Interface)
{
limNode.Accessibility = Types.AccessibilityKind.ackPublic;
limNode.IsAbstract = true;
}
#region MethodKind
Types.MethodKind limKind = Types.MethodKind.mekNormal;
switch (roslynNode.MethodKind)
{
case MethodKind.Constructor:
limKind = Types.MethodKind.mekConstructor;
break;
case MethodKind.Conversion:
limKind = Types.MethodKind.mekOperator;
break;
case MethodKind.Destructor:
limKind = Types.MethodKind.mekDestructor;
break;
case MethodKind.UserDefinedOperator:
limKind = Types.MethodKind.mekOperator;
break;
default:
break;
}
if (roslynNode.Name.Length >= 3)
{
string firstThree = roslynNode.Name.Substring(0, 3);
if (firstThree == "get")
{
limKind = Types.MethodKind.mekGet;
}
else if (firstThree == "set")
{
limKind = Types.MethodKind.mekSet;
}
else if (firstThree == "add")
{
limKind = Types.MethodKind.mekAdd;
}
if (roslynNode.Name.Length >= "remove".Length)
{
firstThree = roslynNode.Name.Substring(0, "remove".Length);
if (firstThree == "remove")
{
limKind = Types.MethodKind.mekRemove;
}
}
}
limNode.MethodKind = limKind;
#endregion MethodKind
limNode.IsVirtual = roslynNode.IsVirtual;
#region returns
var returnType = roslynNode.ReturnType;
if (returnType != null)
{
SyntaxNode _m;
if (!returnType.IsInMetadata())
{
var originalDef = returnType.GetDefinition(out _m);
if (originalDef != null && originalDef.Kind == returnType.Kind)
{
Commons.Common.Safe_Edge(limNode, "Returns", originalDef.GetLimType().Id);
}
}
else
{
Lim.Asg.Nodes.Type.Type node = returnType.GetLimType();
MainDeclaration.Instance.LimFactory.setFiltered(node.Id);
Commons.Common.Safe_Edge(limNode, "Returns", node.Id);
}
limNode.MangledName += returnType.ToString();
limNode.DemangledName = limNode.MangledName;
}
#endregion
#region hasParamter
foreach (var roslynParameter in roslynNode.Parameters)
{
Base limParameter = roslynParameter.ConvertToLimNode();
if (limParameter == null)
{
return;
}
FillData(limParameter, roslynParameter, setHasMember);
}
#endregion
//canThrow
//already handling in visitor
}
