/// <summary>
/// Adds a new hasArguments edge to the node.
/// </summary>
/// <param name="nodeId">[in] The end point of the new hasArguments edge.</param>
/// <param name="acValue">[in] The value of the association class.</param>
/// <exception cref="Columbus.Lim.Asg.LimException">Throws LimException if the given nodeId is invalid.</exception>
public void addHasArguments(uint nodeId, Types.TypeArgumentConstraintKind acValue)
{
if (!fact.getExist(nodeId))
{
throw new LimException("Columbus.Lim.Asg.Nodes.Logical.MethodGenericSpec.addHasArguments(NodeId)", "The end point of the edge does not exist.");
}
Columbus.Lim.Asg.Nodes.Base.Base node = fact.getRef(nodeId);
if (Common.getIsBaseClassKind(node.NodeKind, Types.NodeKind.ndkType))
{
ListIteratorAssoc <Columbus.Lim.Asg.Nodes.Type.Type> .AssocEdge ac = new ListIteratorAssoc <Columbus.Lim.Asg.Nodes.Type.Type> .AssocEdge();
ac.assocClass = new ListIteratorAssoc <Columbus.Lim.Asg.Nodes.Type.Type> .AssocClass();
ac.id = nodeId;
ac.assocClass.acTypeArgumentConstraintKind = acValue;
hasArgumentsAssocContainer.AddLast(ac);
}
else
{
throw new LimException("Columbus.Lim.Asg.Nodes.Logical.MethodGenericSpec.setHasArguments(NodeId)", "Invalid NodeKind (" + node.NodeKind.ToString() + ").");
}
if (fact.ReverseEdges != null)
{
fact.ReverseEdges.insertEdge(nodeId, this.Id, Types.EdgeKind.edkMethodGenericSpec_HasArguments);
}
}
/// <summary>
/// Loads the node.
/// </summary>
/// <param name="io">[in] The node is read from io.</param>
/// <exception cref="Columbus.ColumbusIOException">Throws ColumbusIOException if there is something wrong with the file.</exception>
public override void load(IO binIo)
{
base.load(binIo);
m_specialize = binIo.readUInt4();
uint _id;
_id = binIo.readUInt4();
while (_id != 0)
{
Types.TypeArgumentConstraintKind _ac = (Types.TypeArgumentConstraintKind)(binIo.readUByte1());
ListIteratorAssoc <Columbus.Lim.Asg.Nodes.Type.Type> .AssocEdge hasArgumentsAc = new ListIteratorAssoc <Columbus.Lim.Asg.Nodes.Type.Type> .AssocEdge();
hasArgumentsAc.assocClass.acTypeArgumentConstraintKind = _ac;
hasArgumentsAc.id = _id;
hasArgumentsAssocContainer.AddLast(hasArgumentsAc);
_id = binIo.readUInt4();
}
}
/// <summary>
/// Loads the node.
/// </summary>
/// <param name="io">[in] The node is read from io.</param>
/// <exception cref="Columbus.ColumbusIOException">Throws ColumbusIOException if there is something wrong with the file.</exception>
public override void load(IO binIo)
{
base.load(binIo);
byte boolValues = binIo.readUByte1();
m_isRealInstance = Convert.ToBoolean(boolValues & 1);
boolValues >>= 1;
uint _id;
_id = binIo.readUInt4();
while (_id != 0)
{
Types.TypeArgumentConstraintKind _ac = (Types.TypeArgumentConstraintKind)(binIo.readUByte1());
ListIteratorAssoc <Columbus.Lim.Asg.Nodes.Type.Type> .AssocEdge hasArgumentsAc = new ListIteratorAssoc <Columbus.Lim.Asg.Nodes.Type.Type> .AssocEdge();
hasArgumentsAc.assocClass.acTypeArgumentConstraintKind = _ac;
hasArgumentsAc.id = _id;
hasArgumentsAssocContainer.AddLast(hasArgumentsAc);
_id = binIo.readUInt4();
}
}
// ---------- Edge setter function(s) ----------
/// <summary>
/// Adds a new hasArguments edge to the node.
/// </summary>
/// <param name="node">[in] The end point of the new hasArguments edge.</param>
/// <param name="acValue">[in] The value of the association class.</param>
/// <exception cref="Columbus.Lim.Asg.LimException">Throws LimException if there is something wrong with the given node.</exception>
public void addHasArguments(Columbus.Lim.Asg.Nodes.Type.Type node, Types.TypeArgumentConstraintKind acValue)
{
addHasArguments(node.Id, acValue);
}
public override void visitMethodGenericSpec_HasArguments(uint begin, uint end, Types.TypeArgumentConstraintKind ac)
{
revEdges.insertEdge(end, begin, Types.EdgeKind.edkMethodGenericSpec_HasArguments);
}
public override void visitClassGenericInstance_HasArguments(uint begin, uint end, Types.TypeArgumentConstraintKind ac)
{
revEdges.insertEdge(end, begin, Types.EdgeKind.edkClassGenericInstance_HasArguments);
}
/// <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);
}