diff --git a/fixture/realclasses/AbstractAllocator.java b/fixture/realclasses/AbstractAllocator.java
new file mode 100644
index 0000000..3652230
--- /dev/null
+++ b/fixture/realclasses/AbstractAllocator.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.cassandra.utils.memory;
+
+import java.nio.ByteBuffer;
+
+import org.apache.cassandra.db.Clustering;
+import org.apache.cassandra.db.Columns;
+import org.apache.cassandra.db.rows.BTreeRow;
+import org.apache.cassandra.db.rows.Cell;
+import org.apache.cassandra.db.rows.Row;
+import org.apache.cassandra.utils.ByteBufferUtil;
+
+public abstract class AbstractAllocator
+{
+    /**
+     * Allocate a slice of the given length.
+     */
+    public ByteBuffer clone(ByteBuffer buffer)
+    {
+        assert buffer != null;
+        if (buffer.remaining() == 0)
+            return ByteBufferUtil.EMPTY_BYTE_BUFFER;
+        ByteBuffer cloned = allocate(buffer.remaining());
+
+        cloned.mark();
+        cloned.put(buffer.duplicate());
+        cloned.reset();
+        return cloned;
+    }
+
+    public abstract ByteBuffer allocate(int size);
+
+    public Row.Builder cloningBTreeRowBuilder()
+    {
+        return new CloningBTreeRowBuilder(this);
+    }
+
+    private static class CloningBTreeRowBuilder extends BTreeRow.Builder
+    {
+        private final AbstractAllocator allocator;
+
+        private CloningBTreeRowBuilder(AbstractAllocator allocator)
+        {
+            super(true);
+            this.allocator = allocator;
+        }
+
+        @Override
+        public void newRow(Clustering clustering)
+        {
+            super.newRow(clustering.copy(allocator));
+        }
+
+        @Override
+        public void addCell(Cell cell)
+        {
+            super.addCell(cell.copy(allocator));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/github/sergdelft/j2graph/ast/JDTVisitor.java b/src/main/java/com/github/sergdelft/j2graph/ast/JDTVisitor.java
index d0f0c3d..eb28300 100644
--- a/src/main/java/com/github/sergdelft/j2graph/ast/JDTVisitor.java
+++ b/src/main/java/com/github/sergdelft/j2graph/ast/JDTVisitor.java
@@ -45,9 +45,11 @@ public boolean visit(TypeDeclaration node) {
         // in the future, if we plan to support sub-classes, this needs to change
         if(classBuilder==null) {
             classBuilder = new ClassGraphBuilder(node.getName().getFullyQualifiedName(), methodInvocations);
+            return super.visit(node);
+        } else {
+            // TODO: it's a sub-class, we ignore it.
+            return false;
         }
-
-        return super.visit(node);
     }
 
     @Override
@@ -499,6 +501,11 @@ public boolean visit(MemberRef node) {
         return super.visit(node);
     }
 
+    public boolean visit(Javadoc node) {
+        /* do nothing */
+        return false;
+    }
+
     public boolean visit(MemberValuePair node) {
         if(!inAMethod())
             return false;
@@ -881,6 +888,10 @@ public boolean visit(Modifier node) {
     // ------------------------------------------------------------------------------------
 
     public void endVisit(Modifier node) {
+
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
@@ -897,108 +908,186 @@ public void endVisit(AnonymousClassDeclaration node) {
     }
 
     public void endVisit(ArrayAccess node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ArrayCreation node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ArrayInitializer node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ArrayType node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(AssertStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(Assignment node) {
         cleanVariableAssignment();
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(Block node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(BlockComment node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
 
     public void endVisit(BreakStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(CastExpression node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(CatchClause node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ClassInstanceCreation node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ConditionalExpression node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ConstructorInvocation node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ContinueStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(CreationReference node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(DoStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(EmptyStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(EnhancedForStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(EnumConstantDeclaration node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(EnumDeclaration node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ExportsDirective node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ExpressionMethodReference node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ExpressionStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(Dimension node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(FieldAccess node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
@@ -1007,10 +1096,16 @@ public void endVisit(FieldDeclaration node) {
     }
 
     public void endVisit(ForStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(IfStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
@@ -1019,58 +1114,97 @@ public void endVisit(ImportDeclaration node) {
     }
 
     public void endVisit(InfixExpression node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(InstanceofExpression node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(Initializer node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(Javadoc node) {
-        popNonTerminal();
+        /* do nothing */
     }
 
     public void endVisit(LabeledStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(LambdaExpression node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(LineComment node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(MarkerAnnotation node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(MemberRef node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(MemberValuePair node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(MethodRef node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(MethodRefParameter node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ModuleDeclaration node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(NameQualifiedType node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
@@ -1079,6 +1213,9 @@ public void endVisit(NormalAnnotation node) {
     }
 
     public void endVisit(OpensDirective node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
@@ -1087,46 +1224,79 @@ public void endVisit(PackageDeclaration node) {
     }
 
     public void endVisit(ParameterizedType node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ParenthesizedExpression node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(PostfixExpression node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(PrefixExpression node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(PrimitiveType node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ProvidesDirective node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(QualifiedName node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(QualifiedType node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(RequiresDirective node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ReturnStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(SimpleType node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
@@ -1135,96 +1305,165 @@ public void endVisit(SingleMemberAnnotation node) {
     }
 
     public void endVisit(SingleVariableDeclaration node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(SuperConstructorInvocation node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(SuperFieldAccess node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(SuperMethodInvocation node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(SuperMethodReference node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(SwitchCase node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(SwitchStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(SynchronizedStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(TagElement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(TextElement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ThisExpression node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(ThrowStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(TryStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
 
     public void endVisit(TypeMethodReference node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(TypeParameter node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(UnionType node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(UsesDirective node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(IntersectionType node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(VariableDeclarationExpression node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(VariableDeclarationStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(VariableDeclarationFragment node) {
+        if(!inAMethod())
+            return;
+
         cleanVariableAssignment();
         popNonTerminal();
     }
 
     public void endVisit(WhileStatement node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
     public void endVisit(WildcardType node) {
+        if(!inAMethod())
+            return;
+
         popNonTerminal();
     }
 
diff --git a/src/test/java/com/github/sergdelft/j2graph/realclasses/AbstractAllocatorTest.java b/src/test/java/com/github/sergdelft/j2graph/realclasses/AbstractAllocatorTest.java
new file mode 100644
index 0000000..0c83749
--- /dev/null
+++ b/src/test/java/com/github/sergdelft/j2graph/realclasses/AbstractAllocatorTest.java
@@ -0,0 +1,25 @@
+package com.github.sergdelft.j2graph.realclasses;
+
+import com.github.sergdelft.j2graph.TestBase;
+import com.github.sergdelft.j2graph.graph.ClassGraph;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * This was failing, mostly because we were not handling
+ * sub classes correctly.
+ * This is somewhat related to #6
+ */
+public class AbstractAllocatorTest extends TestBase {
+
+    private ClassGraph graph = run("realclasses/AbstractAllocator.java");
+
+    @Test
+    void ignore_sub_classes() {
+        // there are 3 methods, as the other two are inside the sub class
+        assertThat(graph.getMethods().stream().map(x -> x.getMethodName()))
+                .containsExactly("clone/1[ByteBuffer]", "allocate/1[int]", "cloningBTreeRowBuilder/0");
+    }
+
+}