/// <summary> /// Sets the hasType edge. /// </summary> /// <param name="node">[in] The new end point of the hasType edge.</param> /// <exception cref="Columbus.Lim.Asg.LimException">Throws LimException if there's something wrong with the given node.</exception> public void setHasType(Columbus.Lim.Asg.Nodes.Type.Type node) { if (m_hasType != 0) { } m_hasType = node.Id; }
/// <summary> /// Adds a new uses edge to the node and inserts it after the other ones. /// </summary> /// <param name="node">[in] The end point of the new uses edge.</param> /// <exception cref="Columbus.Lim.Asg.LimException">Throws LimException if there is something wrong with the given node.</exception> public void addUses(Columbus.Lim.Asg.Nodes.Type.Type node) { addUses(node.Id); }
/// <summary> /// Abstract end visitor, which calls the end visitor of the base class (Columbus.Lim.Asg.Nodes.Base.Base) of the Columbus.Lim.Asg.Nodes.Type.Type node. /// </summary> /// <param name="node">[in] The node which is visited.</param> public override void visitEnd(Columbus.Lim.Asg.Nodes.Type.Type node, bool callVirtualBase) { visitEnd((Columbus.Lim.Asg.Nodes.Base.Base)node, false); }
// ---------- 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); }
/// <summary> /// Deselects the actual node (and only this). /// </summary> /// <param name="node">[in] The node which is visited.</param> public override void visitEnd(Columbus.Lim.Asg.Nodes.Type.Type node, bool callVirtualBase) { selector(node.Id); }
/// <summary> /// Adds a new instantiates edge to the node and inserts it after the other ones. /// </summary> /// <param name="node">[in] The end point of the new instantiates edge.</param> /// <exception cref="Columbus.Lim.Asg.LimException">Throws LimException if there is something wrong with the given node.</exception> public void addInstantiates(Columbus.Lim.Asg.Nodes.Type.Type node) { addInstantiates(node.Id); }
/// <summary> /// Adds a new canThrow edge to the node and inserts it after the other ones. /// </summary> /// <param name="node">[in] The end point of the new canThrow edge.</param> /// <exception cref="Columbus.Lim.Asg.LimException">Throws LimException if there is something wrong with the given node.</exception> public void addCanThrow(Columbus.Lim.Asg.Nodes.Type.Type node) { addCanThrow(node.Id); }
/// <summary> /// Adds a new isSubclass edge to the node and inserts it after the other ones. /// </summary> /// <param name="node">[in] The end point of the new isSubclass edge.</param> /// <exception cref="Columbus.Lim.Asg.LimException">Throws LimException if there is something wrong with the given node.</exception> public void addIsSubclass(Columbus.Lim.Asg.Nodes.Type.Type node) { addIsSubclass(node.Id); }
/// <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> /// Adds a new hasType edge to the node and inserts it after the other ones. /// </summary> /// <param name="node">[in] The end point of the new hasType edge.</param> /// <exception cref="Columbus.Lim.Asg.LimException">Throws LimException if there is something wrong with the given node.</exception> public void addHasType(Columbus.Lim.Asg.Nodes.Type.Type node) { addHasType(node.Id); }
// ---------- Edge setter function(s) ---------- /// <summary> /// Adds a new hasParameterConstraint edge to the node and inserts it after the other ones. /// </summary> /// <param name="node">[in] The end point of the new hasParameterConstraint edge.</param> /// <exception cref="Columbus.Lim.Asg.LimException">Throws LimException if there is something wrong with the given node.</exception> public void addHasParameterConstraint(Columbus.Lim.Asg.Nodes.Type.Type node) { addHasParameterConstraint(node.Id); }
// ---------- Edge setter function(s) ---------- /// <summary> /// Adds a new hasParameterType edge to the node. /// </summary> /// <param name="node">[in] The end point of the new hasParameterType 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 addHasParameterType(Columbus.Lim.Asg.Nodes.Type.Type node, Types.ParameterKind acValue) { addHasParameterType(node.Id, acValue); }