Merge branch 'carlos' into develop

# Conflicts:
#	sdg-core/src/main/java/es/upv/mist/slicing/nodes/VariableAction.java

Author: cargaji

sdg-core/src/main/java/es/upv/mist/slicing/graphs/ClassGraph.java

@@ -81,7 +81,7 @@ protected VariableAction locateVAVariableDeclarator(String realName) {
                 else if (foundDecl)
                     return lastDef;
             } else if (a.isDefinition() && a.getName().equals(root)) {
-                if (root.equals(realName) || a.hasTreeMember(realName))
+                if (root.equals(realName) || a.hasPolyTreeMember(realName))
                     lastDef = a;
             }
         }
@@ -196,14 +196,14 @@ public void visit(MethodCallExpr n, String arg) {
                 visitCall(n, arg);
             }
 
-            protected void visitCall(Expression call, String arg) {
-                if (ASTUtils.shouldVisitArgumentsForMethodCalls((Resolvable<? extends ResolvedMethodLikeDeclaration>) call))
+            protected void visitCall(Resolvable<? extends ResolvedMethodLikeDeclaration> call, String arg) {
+                if (ASTUtils.shouldVisitArgumentsForMethodCalls(call))
                     return;
                 VariableAction lastUseOut = null;
                 for (VariableAction variableAction : graphNode.getVariableActions()) {
                     if (variableAction instanceof VariableAction.CallMarker) {
                         VariableAction.CallMarker marker = (VariableAction.CallMarker) variableAction;
-                        if (ASTUtils.equalsWithRange((Node) marker.getCall(), call) && !marker.isEnter()) {
+                        if (ASTUtils.equalsWithRange((Node) marker.getCall(), (Node) call) && !marker.isEnter()) {
                             assert lastUseOut != null;
                             list.add(new Pair<>(lastUseOut, arg));
                             return;
@@ -252,7 +252,10 @@ protected void markTransference(Pair<VariableAction, String> sourcePair, Variabl
         VariableAction sourceAction = sourcePair.a;
         String sourceMember = sourcePair.b;
         if (targetAction.hasObjectTree()) {
-            ObjectTree.copyTargetTreeToSource(sourceAction.getObjectTree(), targetAction.getObjectTree(), sourceMember, targetMember);
+            boolean sourceTypesInClassGraph = sourceAction.getDynamicTypes().stream()
+                    .anyMatch(ClassGraph.getInstance()::containsType);
+            if (sourceTypesInClassGraph && !sourceAction.hasObjectTree())
+                ObjectTree.copyTargetTreeToSource(sourceAction.getObjectTree(), targetAction.getObjectTree(), sourceMember, targetMember);
             sourceAction.setPDGTreeConnectionTo(targetAction, sourceMember, targetMember);
         } else {
             sourceAction.setPDGValueConnection(sourceMember);

sdg-core/src/main/java/es/upv/mist/slicing/graphs/ExpressionObjectTreeFinder.java

@@ -77,7 +77,7 @@ public List<VariableAction> findLastDefinitionOfObjectRoot(VariableAction usage)
     /** Given a field declaration, locate all definitions that affect the given member. */
     public List<VariableAction> findAllFutureObjectDefinitionsFor(VariableAction action) {
         List<VariableAction> list = new LinkedList<>();
-        Predicate<VariableAction> filter = a -> a.isDefinition() && a.getName().equals("this") && a.hasTreeMember(action.getName());
+        Predicate<VariableAction> filter = a -> a.isDefinition() && a.getName().equals("this") && a.hasPolyTreeMember(action.getName());
         findAllFutureVarActionsFor(new HashSet<>(), list, action.getGraphNode(), action, filter);
         return list;
     }

sdg-core/src/main/java/es/upv/mist/slicing/graphs/jsysdg/JSysCFG.java

@@ -54,8 +54,8 @@ protected void addFlowDependencyArc(VariableAction source, VariableAction target
     }
 
     protected void addDeclarationFlowDependencyArc(VariableAction declaration, VariableAction definition) {
-        MemberNode defMember = definition.getObjectTree().getNodeFor(declaration.getName());
-        addEdge(graphNodeOf(declaration), defMember, new FlowDependencyArc());
+        for (MemberNode target : definition.getObjectTree().getNodesForPoly(declaration.getName()))
+            addEdge(graphNodeOf(declaration), target, new FlowDependencyArc());
     }
 
     // definicion de miembro --flow--> uso de miembro

sdg-core/src/main/java/es/upv/mist/slicing/graphs/jsysdg/JSysPDG.java

@@ -31,11 +31,8 @@ protected Set<SyntheticNode<?>> getFormalOutNodes(CallableDeclaration<?> declara
                 continue;
             assert node.getVariableActions().size() == 1;
             VariableAction action = node.getVariableActions().get(0);
-            if (action.hasObjectTree()) {
-                set.add(action.getObjectTree().getMemberNode());
-                for (MemberNode memberNode : action.getObjectTree().nodeIterable())
-                    set.add(memberNode);
-            }
+            if (action.hasObjectTree())
+                set.addAll(action.getObjectTree().leaves());
         }
         return set;
     }

sdg-core/src/main/java/es/upv/mist/slicing/graphs/jsysdg/SummaryArcAnalyzer.java

@@ -1,11 +1,18 @@
 package es.upv.mist.slicing.nodes;
 
+import com.github.javaparser.resolution.types.ResolvedType;
 import es.upv.mist.slicing.nodes.oo.MemberNode;
+import es.upv.mist.slicing.nodes.oo.PolyMemberNode;
 import es.upv.mist.slicing.utils.Utils;
 
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static es.upv.mist.slicing.graphs.cfg.CFGBuilder.VARIABLE_NAME_OUTPUT;
+import static es.upv.mist.slicing.graphs.exceptionsensitive.ESCFG.ACTIVE_EXCEPTION_VARIABLE;
 
 /**
  * A tree data structure that mimics the tree found in an object's fields.
@@ -22,7 +29,7 @@ public class ObjectTree implements Cloneable {
     public static final String ROOT_NAME = "-root-";
 
     /** Regex pattern to split the root from the fields of a field access expression. */
-    private static final Pattern FIELD_SPLIT = Pattern.compile("^(?<root>(([_0-9A-Za-z]+\\.)*this)|([_0-9A-Za-z]+)|(-root-))(\\.(?<fields>.+))?$");
+    private static final Pattern FIELD_SPLIT = Pattern.compile("^(?<root>(([_0-9A-Za-z]+\\.)*this)|([_0-9A-Za-z]+)|(" + ROOT_NAME + ")|(" + VARIABLE_NAME_OUTPUT + ")|(" + ACTIVE_EXCEPTION_VARIABLE + "))(\\.(?<fields>.+))?$");
 
     /** Direct children of this tree node, mapped by field name. */
     private final Map<String, ObjectTree> childrenMap = new HashMap<>();
@@ -36,12 +43,22 @@ public ObjectTree() {
 
     /** Create a root of a new object tree with the given name. */
     public ObjectTree(String memberName) {
-        memberNode = new MemberNode(memberName, null);
+        this(new MemberNode(memberName, null));
     }
 
     /** Create a child tree node for the given field, whose node is linked to the given parent. */
     private ObjectTree(String memberName, ObjectTree parent) {
-        this.memberNode = new MemberNode(memberName, parent.memberNode);
+        this(new MemberNode(memberName, parent.memberNode));
+    }
+
+    /** Create a child tree node for the given type, whose node is linked to the given parent. */
+    private ObjectTree(ResolvedType resolvedType, ObjectTree parent) {
+        this(new PolyMemberNode(resolvedType, parent.memberNode));
+    }
+
+    /** Create a child tree with the given member node. */
+    private ObjectTree(MemberNode memberNode) {
+        this.memberNode = memberNode;
     }
 
     /** The name of the variable or field represented by this tree. It doesn't include ancestors. */
@@ -58,6 +75,44 @@ public boolean hasChildren() {
         return !childrenMap.isEmpty();
     }
 
+    /** Whether the field passed as argument has children. */
+    public boolean hasChildren(String memberWithRoot) {
+        String member = removeRoot(memberWithRoot);
+        if (member.isEmpty())
+            return hasChildren();
+        return hasChildrenInternal(member);
+    }
+
+    protected boolean hasChildrenInternal(String members) {
+        if (members.contains(".")) {
+            int firstDot = members.indexOf('.');
+            String first = members.substring(0, firstDot);
+            String rest = members.substring(firstDot + 1);
+            childrenMap.computeIfAbsent(first, f -> new ObjectTree(f, this));
+            return childrenMap.get(first).hasChildrenInternal(rest);
+        } else {
+            return childrenMap.get(members).hasChildren();
+        }
+    }
+
+    /** Whether this object tree immediately contains polymorphic nodes. */
+    public boolean hasPoly() {
+        return childrenMap.values().stream().anyMatch(ot -> ot.getMemberNode() instanceof PolyMemberNode);
+    }
+
+    /** A set of entry pairs, containing the field name and its corresponding tree. It is unmodifiable. */
+    public Set<Map.Entry<String, ObjectTree>> entrySet() {
+        return Collections.unmodifiableSet(childrenMap.entrySet());
+    }
+
+    /** Insert a polymorphic node for the given type. The type node will be
+     *  generated immediately beneath this tree node. */
+    public ObjectTree addType(ResolvedType rt) {
+        assert !rt.describe().isBlank();
+        assert !(memberNode instanceof PolyMemberNode);
+        return childrenMap.computeIfAbsent(rt.describe(), n -> new ObjectTree(rt, this));
+    }
+
     /**
      * Insert a field with the given name. This method should only be called on a root object tree.
      * This method may be used to add multiple levels simultaneously, calling this method with
@@ -66,22 +121,30 @@ public boolean hasChildren() {
      * @param fieldName The field to be added, should include the root variable name. For example,
      *                  to add the field "x" to a variable "a", this argument should be "a.x".
      */
-    public void addField(String fieldName) {
+    public ObjectTree addField(String fieldName) {
         String members = removeRoot(fieldName);
-        addNonRootField(members);
+        return addNonRootField(members);
+    }
+
+    /** Insert a field in the current level of object tree. The field should be a variable name,
+     *  and not contain dots or be blank. */
+    public ObjectTree addImmediateField(String fieldName) {
+        if (fieldName.contains(".") || fieldName.isBlank())
+            throw new IllegalArgumentException("field name must not include dots or be blank!");
+        return childrenMap.computeIfAbsent(fieldName, f -> new ObjectTree(f, this));
     }
 
     /** Similar to {@link #addField(String)}, but may be called at any level
      *  and the argument must not contain the root variable. */
-    private void addNonRootField(String members) {
+    private ObjectTree addNonRootField(String members) {
         if (members.contains(".")) {
             int firstDot = members.indexOf('.');
             String first = members.substring(0, firstDot);
             String rest = members.substring(firstDot + 1);
             childrenMap.computeIfAbsent(first, f -> new ObjectTree(f, this));
-            childrenMap.get(first).addNonRootField(rest);
+            return childrenMap.get(first).addNonRootField(rest);
         } else {
-            childrenMap.computeIfAbsent(members, f -> new ObjectTree(f, this));
+            return childrenMap.computeIfAbsent(members, f -> new ObjectTree(f, this));
         }
     }
 
@@ -96,25 +159,39 @@ public void addAll(ObjectTree tree) {
     }
 
     /**
-     * Copies a subtree from source into another subtree in target.
-     *
+     * Copies a subtree from source into another subtree in target. The tree may be
+     * pasted multiple times, if there are polymorphic nodes that are not explicitly marked
+     * in the prefix arguments.
      * @param source       The source of the nodes.
      * @param target       The tree where nodes will be added
      * @param sourcePrefix The prefix to be consumed before copying nodes. Without root.
      * @param targetPrefix The prefix to be consumed before copying nodes. Without root.
      */
     public static void copyTargetTreeToSource(ObjectTree source, ObjectTree target, String sourcePrefix, String targetPrefix) {
-        ObjectTree a = source.findObjectTreeOfMember(sourcePrefix);
-        ObjectTree b = target.findObjectTreeOfMember(targetPrefix);
-        a.addAll(b);
+        Collection<ObjectTree> a = source.findObjectTreeOfPolyMember(sourcePrefix);
+        Collection<ObjectTree> b = target.findObjectTreeOfPolyMember(targetPrefix);
+        for (ObjectTree sourceTree : a)
+            for (ObjectTree targetTree : b)
+                sourceTree.addAll(targetTree);
     }
 
-    /**
-     * Locate an object tree that represents a field of this object.
-     * @param member The field, without a root prefix.
-     */
-    ObjectTree findObjectTreeOfMember(String member) {
-        ObjectTree result = this;
+    /** Obtains the set of nodes in this object tree that have no children. */
+    public Collection<MemberNode> leaves() {
+        return streamLeaves().collect(Collectors.toSet());
+    }
+
+    /** @see #leaves() */
+    protected Stream<MemberNode> streamLeaves() {
+        if (childrenMap.isEmpty())
+            return Stream.of(memberNode);
+        return childrenMap.values().stream()
+                .flatMap(ObjectTree::streamLeaves);
+    }
+
+    /** Similar to {@link #getNodesForPoly(String)}, but returns object trees
+     *  instead of member nodes. */
+    Collection<ObjectTree> findObjectTreeOfPolyMember(String member) {
+        Collection<ObjectTree> result = List.of(this);
         while (!member.isEmpty()) {
             int firstDot = member.indexOf('.');
             String first, rest;
@@ -125,7 +202,22 @@ ObjectTree findObjectTreeOfMember(String member) {
                 first = member;
                 rest = "";
             }
-            result = result.childrenMap.get(first);
+            result = result.stream().flatMap(res -> {
+                ObjectTree ot = res.childrenMap.get(first);
+                if (ot == null && res.childrenMap.size() > 0) {
+                    Collection<ObjectTree> collection = new LinkedList<>();
+                    for (ObjectTree child : childrenMap.values()) {
+                        if (!(child.getMemberNode() instanceof PolyMemberNode) || !child.childrenMap.containsKey(first))
+                            throw new IllegalArgumentException("Could not locate member in object tree");
+                        collection.add(child.childrenMap.get(first));
+                    }
+                    return collection.stream();
+                } else if (ot == null) {
+                    throw new IllegalArgumentException("Could not locate member in object tree");
+                } else {
+                    return Stream.of(ot);
+                }
+            }).collect(Collectors.toList());
             member = rest;
         }
         return result;
@@ -134,19 +226,34 @@ ObjectTree findObjectTreeOfMember(String member) {
     /** Whether this object tree contains the given member. The argument should contain the root variable name. */
     public boolean hasMember(String member) {
         String field = removeRoot(member);
-        return hasNonRootMember(field);
+        return hasNonRootMember(field, false);
+    }
+
+    /** Whether this object tree contains the given member. The argument may omit typing
+     *  information (i.e., 'a.x' will find 'a.A.x', where A is a polymorphic node). */
+    public boolean hasPolyMember(String member) {
+        String field = removeRoot(member);
+        return hasNonRootMember(field, true);
     }
 
     /** Similar to hasMember, but valid at any level of the tree and the argument should not contain
      *  the root variable's name.
      *  @see #hasMember(String) */
-    private boolean hasNonRootMember(String members) {
+    private boolean hasNonRootMember(String members, boolean polymorphic) {
         if (members.contains(".")) {
             int firstDot = members.indexOf('.');
             String first = members.substring(0, firstDot);
             String rest = members.substring(firstDot + 1);
-            return childrenMap.containsKey(first) && childrenMap.get(first).hasNonRootMember(rest);
+            if (polymorphic && !childrenMap.containsKey(first) && !childrenMap.isEmpty())
+                return childrenMap.values().stream()
+                        .filter(ot -> ot.getMemberNode() instanceof PolyMemberNode)
+                        .anyMatch(ot -> ot.hasNonRootMember(members, true));
+            return childrenMap.containsKey(first) && childrenMap.get(first).hasNonRootMember(rest, polymorphic);
         } else {
+            if (polymorphic && !childrenMap.containsKey(members) && !childrenMap.isEmpty())
+                return childrenMap.values().stream()
+                        .filter(ot -> ot.getMemberNode() instanceof PolyMemberNode)
+                        .anyMatch(ot -> ot.hasNonRootMember(members, true));
             return childrenMap.containsKey(members);
         }
     }
@@ -174,6 +281,16 @@ MemberNode getNodeForNonRoot(String members) {
         }
     }
 
+    /** Similar to {@link #getNodeFor(String)}, but if the argument does not contain
+     *  types, it will obtain all member nodes that represent a given field (in multiple
+     *  types). For example, the argument 'a.x' may produce 'a.A.x' and 'a.B.x'; whereas
+     *  the argument 'a.A.x' will only produce one node. */
+    public Collection<MemberNode> getNodesForPoly(String memberWithRoot) {
+        return findObjectTreeOfPolyMember(removeRoot(memberWithRoot)).stream()
+                .map(ObjectTree::getMemberNode)
+                .collect(Collectors.toList());
+    }
+
     /** @return An iterable through the names (with full prefixes) of all members of this tree,
      *  excluding the root. */
     public Iterable<String> nameIterable() {
@@ -192,14 +309,16 @@ public String next() {
                 MemberNode node = element.memberNode;
                 if (node == null)
                     return ROOT_NAME;
+                else if (node instanceof PolyMemberNode)
+                    return next();
                 else
                     builder.append(node.getLabel());
-                while (node.getParent() instanceof MemberNode && node.getParent().getLabel().matches("^(USE|DEF|DEC)\\{")) {
+                while (node.getParent() instanceof MemberNode) {
                     node = (MemberNode) node.getParent();
                     builder.insert(0, '.');
                     builder.insert(0, node.getLabel());
                 }
-                return builder.insert(0, ROOT_NAME + ".").toString();
+                return builder.toString();
             }
         };
     }
@@ -248,11 +367,6 @@ public ObjectTree next() {
         };
     }
 
-    /** @see #treeIterator() */
-    Iterable<ObjectTree> treeIterable() {
-        return this::treeIterator;
-    }
-
     @SuppressWarnings("MethodDoesntCallSuperMethod")
     @Override
     public Object clone() {
@@ -263,7 +377,7 @@ public Object clone() {
     }
 
     private ObjectTree clone(ObjectTree parent) {
-        ObjectTree clone = new ObjectTree(getMemberName(), parent);
+        ObjectTree clone = new ObjectTree(getMemberNode().copyToParent(parent.getMemberNode()));
         for (Map.Entry<String, ObjectTree> entry : childrenMap.entrySet())
             clone.childrenMap.put(entry.getKey(), entry.getValue().clone(clone));
         return clone;