/// <summary> /// Adds a new type expression. /// </summary> /// <param name="type">WriteType expression to add.</param> /// <returns>If the type has been added</returns> public bool AddType(TypeExpression type) { bool added = true; IntersectionType intersection = TypeExpression.As <IntersectionType>(type); if (intersection != null) { foreach (TypeExpression t in intersection.typeSet) { added = added && this.AddType(t); } this.ValidTypeExpression = false; return(added); } Predicate <TypeExpression> predicate = delegate(TypeExpression te2) { return((bool)te2.AcceptOperation(new EquivalentOperation(type), null)); }; if (this.typeSet.Find(predicate) == null) { this.typeSet.Add(type); this.ValidTypeExpression = false; return(true); } return(false); }
// SSA #region Clone() /// <summary> /// Clones a type to be used in SSA. It must taken into account that: /// - In case it has no type variables, no clone is performed /// - WriteType variables, equivalence classes and substitutions are cloned /// </summary> /// <param name="clonedTypeVariables">WriteType variables that have been cloned.</param> /// <param name="equivalenceClasses">Equivalence classes of the type cloned variables. These /// equivalence classes need to be updated with the new cloned type variables.</param> /// <param name="methodAnalyzed">The method that is being analyzed when the operation is performed.</param> /// <returns>The cloned type</returns> internal override TypeExpression Clone(IDictionary <int, TypeVariable> clonedTypeVariables, IList <EquivalenceClass> equivalenceClasses, MethodType methodAnalyzed) { if (!this.HasTypeVariables()) { return(this); } IntersectionType newIntersectionType = (IntersectionType)this.MemberwiseClone(); newIntersectionType.typeSet = new List <TypeExpression>(); // * Clones all the types in the union foreach (TypeExpression type in this.typeSet) { newIntersectionType.typeSet.Add(type.Clone(clonedTypeVariables, equivalenceClasses, methodAnalyzed)); } return(newIntersectionType); }
/// <summary> /// Method that clones each type variable of a type expression. /// Equivalence classes are not cloned (but included in the equivalenceClasses parameter. /// The default implementation is do nothing (for built-in types). /// </summary> /// <param name="typeVariableMappings">Each new type varaiable represent a copy of another existing one. /// This parameter is a mapping between them, wher tmpName=old and value=new</param> /// <param name="equivalenceClasses">Each equivalence class of all the type variables.</param> /// <param name="clonedClasses">This parameter collects the set of all cloned classes. It is used to detect infinite recursion.</param> /// <returns>The new type expression (itself by default)</returns> public override TypeExpression CloneTypeVariables(IDictionary <TypeVariable, TypeVariable> typeVariableMappings, IList <EquivalenceClass> equivalenceClasses, IList <ClassType> clonedClasses) { if (!this.HasTypeVariables()) { return(this); } IntersectionType newType = (IntersectionType)this.MemberwiseClone(); IList <TypeExpression> oldTypeSet = this.typeSet; newType.typeSet = new List <TypeExpression>(); foreach (TypeExpression oldType in oldTypeSet) { newType.typeSet.Add(oldType.CloneTypeVariables(typeVariableMappings, equivalenceClasses, clonedClasses)); } newType.ValidTypeExpression = false; return(newType); }