ctf: Attempt to correct scoped lookups

Remove infinite recurstion if something is not found. (due to roles in ctf2)

Change-Id: Ifa62ed5807a17e307c044e066399cf15fae2bc74
Signed-off-by: Matthew Khouzam <matthew.khouzam@ericsson.com>

Author: MatthewKhouzam

ctf/org.eclipse.tracecompass.ctf.core/src/org/eclipse/tracecompass/ctf/core/event/types/ScopedDefinition.java

@@ -20,9 +20,7 @@
 import org.eclipse.tracecompass.ctf.core.event.scope.ILexicalScope;
 
 /**
- * Scoped defintion. a defintion where you can lookup various datatypes
- *
- * TODO: replace by default methods and an interface when java 8 is upon us
+ * Scoped definition. a definition where you can lookup various datatypes
  *
  * @author Matthew Khouzam
  */
@@ -150,4 +148,21 @@ public VariantDefinition lookupVariant(String name) {
         IDefinition def = lookupDefinition(name);
         return (VariantDefinition) ((def instanceof VariantDefinition) ? def : null);
     }
-}
+
+
+    /**
+     * Lookup definition while excluding the caller
+     *
+     * @param lookupPath
+     *            the path to lookup
+     * @param definitionToExclude
+     *            the definition to exclude, can be null
+     * @return the definition or null
+     * @since 5.1
+     */
+    public @Nullable IDefinition lookupDefinition(@Nullable String lookupPath, @Nullable ScopedDefinition definitionToExclude) {
+        if(definitionToExclude == this) {
+            return null;
+        }
+        return lookupDefinition(lookupPath, definitionToExclude);
+    }}

ctf/org.eclipse.tracecompass.ctf.core/src/org/eclipse/tracecompass/ctf/core/event/types/StructDeclaration.java

@@ -15,7 +15,9 @@
 package org.eclipse.tracecompass.ctf.core.event.types;
 
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.regex.Pattern;
 
 import org.eclipse.jdt.annotation.NonNull;
@@ -54,6 +56,8 @@ public class StructDeclaration extends Declaration {
     private @NonNull String[] fFieldNames;
     /** Field declarations */
     private @NonNull IDeclaration[] fFields;
+    /** Role declarations */
+    private final @NonNull Map<String, IDeclaration> fRoles = new HashMap<>();
 
     /** maximum bit alignment */
     private long fMaxAlign;
@@ -209,6 +213,10 @@ public void addField(@NonNull String name, @NonNull IDeclaration declaration) {
         fields[length] = declaration;
         fFieldNames = names;
         fFields = fields;
+        String role = declaration.getRole();
+        if(null != role && !role.isEmpty()) {
+            fRoles.put(role, declaration);
+        }
         fMaxAlign = Math.max(fMaxAlign, declaration.getAlignment());
     }
 
@@ -337,6 +345,12 @@ public String toString() {
         return sb.toString();
     }
 
+    @Override
+    public void setRole(String role) {
+        super.setRole(role);
+        fRoles.put(role, this);
+    }
+
     @Override
     public int hashCode() {
         final int prime = 31;
@@ -405,4 +419,14 @@ public boolean isBinaryEquivalent(IDeclaration obj) {
         return (fMaxAlign == other.fMaxAlign);
     }
 
+    /**
+     * Get the child with a role
+     * @param role the role
+     * @return the role
+     * @since 5.1
+     */
+    public @Nullable IDeclaration getRole(String role) {
+        return fRoles.get(role);
+    }
+
 }

ctf/org.eclipse.tracecompass.ctf.core/src/org/eclipse/tracecompass/ctf/core/event/types/StructDefinition.java

@@ -181,16 +181,13 @@ public String toString() {
     }
 
     /**
-     * Lookup definition while exclusing the caller
-     *
-     * @param lookupPath
-     *            the path to lookup
-     * @param defintionToExclude
-     *            the definition to exclude, can be null
-     * @return the definition or null
      * @since 1.1
      */
-    public Definition lookupDefinition(String lookupPath, ScopedDefinition defintionToExclude) {
+    @Override
+    public Definition lookupDefinition(String lookupPath, ScopedDefinition definitionToExclude) {
+        if (this.equals(definitionToExclude) || lookupPath == null) {
+            return null;
+        }
         /*
          * The fields are created in order of appearance, so if a variant or
          * sequence refers to a field that is after it, the field's definition
@@ -206,18 +203,24 @@ public Definition lookupDefinition(String lookupPath, ScopedDefinition defintion
             return fDefinitions[val];
         }
         for (IDefinition child : fDefinitions) {
-            if (child instanceof ScopedDefinition) {
-                if (!child.equals(defintionToExclude)) {
-                    IDefinition def = ((ScopedDefinition) child).lookupDefinition(lookupPath);
-                    if (def instanceof Definition) {
-                        return (Definition) def;
+            if (child instanceof ScopedDefinition scopedChild) {
+                if (!child.equals(definitionToExclude)) {
+                    if (lookupPath.equals(child.getDeclaration().getRole())) {
+                        return scopedChild;
+                    }
+                    IDefinition def = scopedChild.lookupDefinition(lookupPath, definitionToExclude);
+                    if (def instanceof Definition childDef) {
+                        return childDef;
                     }
                 }
             }
         }
         if (getDefinitionScope() instanceof InternalDef) {
             return (Definition) ((InternalDef) getDefinitionScope()).lookupDefinitionBreakLoop(lookupPath);
         }
+        if (getDefinitionScope() instanceof ScopedDefinition) {
+            return (Definition) ((ScopedDefinition) getDefinitionScope()).lookupDefinition(lookupPath, this);
+        }
         return (Definition) getDefinitionScope().lookupDefinition(lookupPath);
     }
 
@@ -231,11 +234,31 @@ public Definition lookupDefinition(String lookupPath, ScopedDefinition defintion
      * @since 4.4
      */
     public IDefinition lookupRole(String role) {
+        if (role == null) {
+            return null;
+        }
         for (IDefinition def : fDefinitions) {
-            IDeclaration decl = def.getDeclaration();
-            if (role != null && role.equals(decl.getRole())) {
+            if (role.equals(def.getDeclaration().getRole())) {
                 return def;
             }
+            IDefinition result = lookupRoleRecursive(def, role);
+            if (result != null) {
+                return result;
+            }
+        }
+        return null;
+    }
+
+    private IDefinition lookupRoleRecursive(IDefinition def, String role) {
+        if (def instanceof StructDefinition) {
+            return ((StructDefinition) def).lookupRole(role);
+        }
+        if (def instanceof VariantDefinition) {
+            IDefinition current = ((VariantDefinition) def).getCurrentField();
+            if (role.equals(current.getDeclaration().getRole())) {
+                return current;
+            }
+            return lookupRoleRecursive(current, role);
         }
         return null;
     }

ctf/org.eclipse.tracecompass.ctf.core/src/org/eclipse/tracecompass/ctf/core/event/types/VariantDefinition.java

@@ -143,8 +143,42 @@ public IDefinition lookupDefinition(String lookupPath) {
         if (lookupPath.equals(fFieldName)) {
             return fDefinition;
         }
+        if (lookupPath.equals(fTagDef.getDeclaration().getRole())) {
+            return fTagDef;
+        }
+        if (lookupPath.equals(fDefinition.getDeclaration().getRole())) {
+            return fDefinition;
+        }
+        if (fDefinition instanceof ScopedDefinition) {
+            IDefinition def = ((ScopedDefinition) fDefinition).lookupDefinition(lookupPath, this);
+            if (def != null) {
+                return def;
+            }
+        }
+        final IDefinitionScope definitionScope = getDefinitionScope();
+        if (definitionScope instanceof StructDefinition) {
+            StructDefinition structDefinition = (StructDefinition) definitionScope;
+            return structDefinition.lookupDefinition(lookupPath, this);
+        }
+        return definitionScope.lookupDefinition(lookupPath);
+    }
+
+    @Override
+    public IDefinition lookupDefinition(String lookupPath, ScopedDefinition definitionToExclude) {
+        if (lookupPath == null) {
+            return null;
+        }
+        if (lookupPath.equals(fFieldName)) {
+            return fDefinition;
+        }
+        if (lookupPath.equals(fTagDef.getDeclaration().getRole())) {
+            return fTagDef;
+        }
+        if (lookupPath.equals(fDefinition.getDeclaration().getRole())) {
+            return fDefinition;
+        }
         if (fDefinition instanceof ScopedDefinition) {
-            IDefinition def = ((ScopedDefinition) fDefinition).lookupDefinition(lookupPath);
+            IDefinition def = ((ScopedDefinition) fDefinition).lookupDefinition(lookupPath, definitionToExclude);
             if (def != null) {
                 return def;
             }