SSAHelper.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- 
// Project rROTOR                                                             
// -------------------------------------------------------------------------- 
// File: SSAInfo.cs                                                          
// Author: Francisco Ortin  -  francisco.ortin@gmail.com                   
// Description:                                                              
//    This helper class offers static methods to save and update types 
//       of references.              
// -------------------------------------------------------------------------- 
// Create date: 08-06-2007                                                    
// Modification date: 08-06-2007                                              

using System;
using System.Collections.Generic;

using AST;
using TypeSystem;
using Tools;
using TypeSystem.Constraints;
using ErrorManagement;
using TypeSystem.Operations;

namespace Semantic.SSAAlgorithm {
    static class SSAHelper {

        #region SimplifyReferencesUsedInBodies()
        public static void SimplifyReferences(IList<SingleIdentifierExpression> references) {
            for (int i = references.Count - 1; i >= 0; i--) {
                // * If it is a class or namespace, we can erase it
                if (references[i].ExpressionType is ClassType || references[i].ExpressionType is NameSpaceType) {
                    references.RemoveAt(i);
                    continue;
                }
                TypeExpression symbolType;
                if (references[i].IdSymbol!=null && (symbolType = references[i].IdSymbol.SymbolType) != null)
                    // * We can erase it if...
                    if (!symbolType.HasTypeVariables() || // it doesn't have free variables
                          symbolType is FieldType || // it is a field
                          symbolType is MethodType || // it is a method
                          symbolType is ArrayType || // it is an array
                          symbolType is PropertyType  // it is a property
                        )
                        references.RemoveAt(i);
            }
        }
        #endregion

        #region CloneTypesOfReferences()
        public static void CloneTypesOfReferences(IList<SingleIdentifierExpression> references, MethodType methodAnalyzed, IDictionary<SingleIdentifierExpression, TypeExpression> typeExpressions) {
            IDictionary<int, TypeVariable> clonedTypeVariables = new Dictionary<int, TypeVariable>();
            IList<EquivalenceClass> equivalenceClasses = new List<EquivalenceClass>();

            // * Clones each type
            foreach (SingleIdentifierExpression singleId in references)
                if (!typeExpressions.ContainsKey(singleId)) // * Previously cloned
                    if (singleId.IdSymbol == null || singleId.IdSymbol.SymbolType == null)
                        typeExpressions[singleId] = null;
                    else
                        typeExpressions[singleId] = singleId.IdSymbol.SymbolType.Clone(clonedTypeVariables, equivalenceClasses, methodAnalyzed);

            // * Clones and updates the equivalence classes
            CloneEquivalenceClasses(clonedTypeVariables, equivalenceClasses, methodAnalyzed);
        }
        public static void CloneTypesOfReferences(IDictionary<SingleIdentifierExpression, TypeExpression> references, MethodType methodAnalyzed, IDictionary<SingleIdentifierExpression, TypeExpression> typeExpressions) {
            IList<SingleIdentifierExpression> list = new List<SingleIdentifierExpression>();
            foreach (KeyValuePair<SingleIdentifierExpression, TypeExpression> pair in references) {
                pair.Key.IdSymbol.SymbolType = pair.Value;
                list.Add(pair.Key);
            }
            CloneTypesOfReferences(list, methodAnalyzed, typeExpressions);
        }
        #endregion

        #region CloneEquivalenceClasses()
        private static void CloneEquivalenceClasses(IDictionary<int, TypeVariable> clonedTypeVariables, IList<EquivalenceClass> equivalenceClasses, MethodType methodAnalyzed) {
            // * Clones and updates the equivalence classes
            foreach (EquivalenceClass oldEquivalenceClass in equivalenceClasses) {
                EquivalenceClass newEquivalenceClass = new EquivalenceClass();
                // * Clones the substitution
                TypeExpression newSubstitution = null;
                if (oldEquivalenceClass.Substitution != null)
                    newSubstitution = oldEquivalenceClass.Substitution.Clone(clonedTypeVariables, equivalenceClasses, methodAnalyzed);
                // * Updates the substitution to the cloned one
                newEquivalenceClass.add(newSubstitution, SortOfUnification.Equivalent, new List<Pair<TypeExpression, TypeExpression>>());
                foreach (int typeVariableNumber in oldEquivalenceClass.TypeVariables.Keys) {
                    // * Adds the cloned type variable to the new equivalence class
                    TypeVariable newTypeVariable = clonedTypeVariables[typeVariableNumber];
                    newEquivalenceClass.TypeVariables[newTypeVariable.Variable] = newTypeVariable;
                    // * Sets the class equivalence of the cloned type variable
                    newTypeVariable.EquivalenceClass = newEquivalenceClass;
                    clonedTypeVariables[typeVariableNumber].ValidTypeExpression = false;
                }
            }
        }

        #endregion
        #region CloneType()
        public static TypeExpression CloneType(TypeExpression typeExpression, MethodType methodAnalyzed) {
            IDictionary<int, TypeVariable> clonedTypeVariables = new Dictionary<int, TypeVariable>();
            IList<EquivalenceClass> equivalenceClasses = new List<EquivalenceClass>();
            TypeExpression newTypeExpression = typeExpression.Clone(clonedTypeVariables, equivalenceClasses, methodAnalyzed);
            CloneEquivalenceClasses(clonedTypeVariables, equivalenceClasses, methodAnalyzed);
            return newTypeExpression;
        }
        #endregion

        #region GetTypesOfReferences()
        public static IDictionary<SingleIdentifierExpression, TypeExpression> GetTypesOfReferences(IList<SingleIdentifierExpression> references) {
            IDictionary<SingleIdentifierExpression, TypeExpression> typeExpressions = new Dictionary<SingleIdentifierExpression, TypeExpression>();
            foreach (SingleIdentifierExpression singleId in references)
                if (singleId.IdSymbol!=null)
                    typeExpressions[singleId] = singleId.IdSymbol.SymbolType;
            return typeExpressions;
        }
        #endregion


        public static IDictionary<SingleIdentifierExpression, TypeExpression> Intersection(IDictionary<SingleIdentifierExpression, TypeExpression> setA, IList<SingleIdentifierExpression> setB) {
            IDictionary<SingleIdentifierExpression, TypeExpression> typeExpressionIntersectionSet = new Dictionary<SingleIdentifierExpression, TypeExpression>();
            foreach (KeyValuePair<SingleIdentifierExpression, TypeExpression> pair in setA)
                if (setB.Contains(pair.Key))
                    typeExpressionIntersectionSet[pair.Key] = pair.Value;
            return typeExpressionIntersectionSet;
        }


        #region SetTypesOfReferences()
        public static void SetTypesOfReferences(IDictionary<SingleIdentifierExpression, TypeExpression> source, IList<SingleIdentifierExpression> destination) {
            foreach (SingleIdentifierExpression singleId in destination)
                if (source.ContainsKey(singleId))
                    singleId.IdSymbol.SymbolType = source[singleId];
        }
        #endregion

        #region SetUnionTypesOfReferences()
        public static void SetUnionTypesOfReferences(IDictionary<SingleIdentifierExpression, TypeExpression> referencesBeforeIfElse,
                                                     IDictionary<SingleIdentifierExpression, TypeExpression> referencesAfterIf,
                                                     IDictionary<SingleIdentifierExpression, TypeExpression> referencesAfterElse,
                                                     MethodType methodAnalyzed, TypeExpression actualImplicitObject) {
            IList<SingleIdentifierExpression> alreadyVisited = new List<SingleIdentifierExpression>();
            foreach (KeyValuePair<SingleIdentifierExpression, TypeExpression> pair in referencesAfterIf) {
                alreadyVisited.Add(pair.Key);
                if (referencesAfterElse.ContainsKey(pair.Key))
                    // * Option 1
                    pair.Key.IdSymbol.SymbolType = UnionType.collect(pair.Value, referencesAfterElse[pair.Key]);
                //pair.Key.IdSymbol.SymbolType.Assignment(UnionType.collect(pair.Value, referencesAfterElse[pair.Key]), AssignmentOperator.Assign, null, SortOfUnification.Override, null, "", 0, 0);
                // * Option 2
                pair.Key.IdSymbol.SymbolType = UnionType.collect(pair.Value, referencesBeforeIfElse[pair.Key]);
                //pair.Key.IdSymbol.SymbolType.Assignment(UnionType.collect(pair.Value, referencesBeforeIfElse[pair.Key]), AssignmentOperator.Assign, null, SortOfUnification.Override, null, "", 0, 0);
            }
            foreach (KeyValuePair<SingleIdentifierExpression, TypeExpression> pair in referencesAfterElse) {
                if (alreadyVisited.Contains(pair.Key))
                    continue;
                alreadyVisited.Add(pair.Key);
                // * Option 2
                pair.Key.IdSymbol.SymbolType = UnionType.collect(pair.Value, referencesBeforeIfElse[pair.Key]);
                //pair.Key.IdSymbol.SymbolType.Assignment(UnionType.collect(pair.Value, referencesBeforeIfElse[pair.Key]), AssignmentOperator.Assign, null, SortOfUnification.Override, null, "", 0, 0);
            }
        }
        #endregion


        public static void SetUnionTypesOfReferences(IDictionary<Block, IDictionary<SingleIdentifierExpression, TypeExpression>> typeExpressionsBeforeSwitch,
                                                     IDictionary<Block, IDictionary<SingleIdentifierExpression, TypeExpression>> typeExpressionsAfterCases,
                                                     IDictionary<SingleIdentifierExpression, TypeExpression> typeExpressionIntersectionSet,
                                                     MethodType methodAnalyzed, TypeExpression actualImplicitObject) {
            // * We set all types to null
            foreach (KeyValuePair<Block, IDictionary<SingleIdentifierExpression, TypeExpression>> pair1 in typeExpressionsBeforeSwitch)
                foreach (KeyValuePair<SingleIdentifierExpression, TypeExpression> pair2 in pair1.Value)
                    pair2.Key.IdSymbol.SymbolType = null;

            // * We set the union types of all the references in a case body
            foreach (KeyValuePair<Block, IDictionary<SingleIdentifierExpression, TypeExpression>> pair1 in typeExpressionsAfterCases)
                foreach (KeyValuePair<SingleIdentifierExpression, TypeExpression> pair2 in pair1.Value)
                    pair2.Key.IdSymbol.SymbolType = UnionType.collect(pair2.Key.IdSymbol.SymbolType, pair2.Value);

            // * We add the initial type to all those symbols that were not used in all the cases
            foreach (KeyValuePair<Block, IDictionary<SingleIdentifierExpression, TypeExpression>> pair1 in typeExpressionsBeforeSwitch)
                foreach (KeyValuePair<SingleIdentifierExpression, TypeExpression> pair2 in pair1.Value)
                    if (typeExpressionIntersectionSet == null || !typeExpressionIntersectionSet.ContainsKey(pair2.Key))
                        pair2.Key.IdSymbol.SymbolType = UnionType.collect(pair2.Key.IdSymbol.SymbolType, pair2.Value);
        }

        #region AssignAttributes()
        public static void AssignAttributes(UserType classType, IList<TypeExpression> typesOfThisAfterCases,
                        MethodType methodAnalyzed, SortOfUnification unification, TypeExpression actualImplicitObject,
                        Location location) {
            if (methodAnalyzed == null)
                return;
            foreach (KeyValuePair<string, AccessModifier> pair in classType.Fields) {
                TypeExpression fieldType = pair.Value.Type;
                TypeExpression unionType = null;
                foreach (TypeExpression typeOfThis in typesOfThisAfterCases) {
                    TypeExpression eachFieldType = getFieldType(typeOfThis, pair.Key);
                    unionType = UnionType.collect(unionType, eachFieldType);
                }
                fieldType.AcceptOperation(new AssignmentOperation(unionType, AssignmentOperator.Assign, methodAnalyzed, unification, actualImplicitObject, location), null);
            }
        }
        public static void AssignAttributes(UserType classType, TypeExpression typeOfThis1, TypeExpression typeOfThis2,
                        MethodType methodAnalyzed, SortOfUnification unification, TypeExpression actualImplicitObject,
                        Location location) {
            if (methodAnalyzed == null)
                return;
            foreach (KeyValuePair<string, AccessModifier> pair in classType.Fields) {
                TypeExpression fieldType = pair.Value.Type,
                    fieldType1 = getFieldType(typeOfThis1, pair.Key),
                    fieldType2 = getFieldType(typeOfThis2, pair.Key);
                TypeExpression unionType = UnionType.collect(fieldType1, fieldType2);
                fieldType.AcceptOperation(new AssignmentOperation(unionType, AssignmentOperator.Assign, methodAnalyzed, unification, actualImplicitObject, location), null);
            }
        }
        private static TypeExpression getFieldType(TypeExpression type, string fieldName) {
            ClassType classType = TypeExpression.As<ClassType>(type);
            if (classType != null) {
                if (!classType.Fields.ContainsKey(fieldName))
                    return null;
                TypeExpression field= classType.Fields[fieldName].Type;
                FieldType fieldType = TypeExpression.As<FieldType>(field);
                if (fieldType == null)
                    return field;
                return fieldType.FieldTypeExpression;
            }
            UnionType unionType = TypeExpression.As<UnionType>(type);
            if (unionType != null) {
                UnionType newUnionType = new UnionType();
                foreach (TypeExpression typeInUnion in unionType.TypeSet) {
                    TypeExpression newType = SSAHelper.getFieldType(typeInUnion, fieldName);
                    newUnionType.AddType(newType);
                }
                return newUnionType;
            }
            return null;
        }

        #endregion
    }
}