ctf: Attempt to correct scopeed 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

@@ -150,4 +150,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 defintionToExclude
+     *            the definition to exclude, can be null
+     * @return the definition or null
+     * @since 5.1
+     */
+    public @Nullable IDefinition lookupDefinition(@Nullable String lookupPath, @Nullable ScopedDefinition defintionToExclude) {
+        if(defintionToExclude == this) {
+            return null;
+        }
+        return lookupDefinition(lookupPath, defintionToExclude);
+    }}

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
      */
+    @Override
     public Definition lookupDefinition(String lookupPath, ScopedDefinition defintionToExclude) {
+        if (this.equals(defintionToExclude) || 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
@@ -208,7 +205,12 @@ public Definition lookupDefinition(String lookupPath, ScopedDefinition defintion
         for (IDefinition child : fDefinitions) {
             if (child instanceof ScopedDefinition) {
                 if (!child.equals(defintionToExclude)) {
-                    IDefinition def = ((ScopedDefinition) child).lookupDefinition(lookupPath);
+                    if (lookupPath.equals(child.getDeclaration().getRole())) {
+                        if (child instanceof Definition) {
+                            return (Definition) child;
+                        }
+                    }
+                    IDefinition def = ((ScopedDefinition) child).lookupDefinition(lookupPath, defintionToExclude);
                     if (def instanceof Definition) {
                         return (Definition) def;
                     }
@@ -218,6 +220,9 @@ public Definition lookupDefinition(String lookupPath, ScopedDefinition defintion
         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);
     }
 

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;
             }