--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeParser.java	Wed Mar 06 18:33:52 2013 +0100
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeParser.java	Tue Mar 12 11:37:32 2013 +0100
@@ -55,7 +55,7 @@
         NodeData node = null;
         try {
             parsedNodes = new HashMap<>();
-            node = parseInnerClassHierarchy((TypeElement) element);
+            node = resolveNode((TypeElement) element);
         } finally {
             parsedNodes = null;
         }
@@ -67,49 +67,45 @@
         return true;
     }
 
-    private NodeData parseInnerClassHierarchy(TypeElement rootType) {
+    private NodeData resolveNode(TypeElement rootType) {
+        String typeName = Utils.getQualifiedName(rootType);
+        if (parsedNodes.containsKey(typeName)) {
+            return parsedNodes.get(typeName);
+        }
+
         List<? extends TypeElement> types = ElementFilter.typesIn(rootType.getEnclosedElements());
+
         List<NodeData> children = new ArrayList<>();
         for (TypeElement childElement : types) {
-            NodeData childNode = parseInnerClassHierarchy(childElement);
+            NodeData childNode = resolveNode(childElement);
             if (childNode != null) {
                 children.add(childNode);
             }
         }
-        NodeData rootNode = resolveNode(rootType);
+        NodeData rootNode = parseNode(rootType);
         if (rootNode == null && children.size() > 0) {
             rootNode = new NodeData(rootType, null, rootType.getSimpleName().toString());
         }
+
+        parsedNodes.put(typeName, rootNode);
+
         if (rootNode != null) {
             children.addAll(rootNode.getDeclaredChildren());
             rootNode.setDeclaredChildren(children);
         }
 
-        return rootNode;
-    }
-
-    private NodeData resolveNode(TypeElement currentType) {
-        String typeName = Utils.getQualifiedName(currentType);
-        if (!parsedNodes.containsKey(typeName)) {
-            NodeData node = parseNode(currentType);
-            if (node != null) {
-                parsedNodes.put(typeName, node);
+        if (Log.DEBUG) {
+            NodeData parsed = parsedNodes.get(typeName);
+            if (parsed != null) {
+                String dump = parsed.dump();
+                String valid = rootNode != null ? "" : " failed";
+                String msg = String.format("Node parsing %s : %s", valid, dump);
+                log.error(msg);
+                System.out.println(msg);
             }
+        }
 
-            if (Log.DEBUG) {
-                NodeData parsed = parsedNodes.get(Utils.getQualifiedName(currentType));
-                if (parsed != null) {
-                    String dump = parsed.dump();
-                    String valid = node != null ? "" : " failed";
-                    String msg = String.format("Node parsing %s : %s", valid, dump);
-                    log.error(msg);
-                    System.out.println(msg);
-                }
-            }
-
-            return node;
-        }
-        return parsedNodes.get(typeName);
+        return rootNode;
     }
 
     private NodeData parseNode(TypeElement type) {
@@ -128,7 +124,7 @@
         boolean needsSplit;
         if (methodNodes != null) {
             needsSplit = methodNodes != null;
-            nodeType = Utils.fromTypeMirror(Utils.getAnnotationValueType(methodNodes, "value"));
+            nodeType = Utils.fromTypeMirror(Utils.getAnnotationValue(TypeMirror.class, methodNodes, "value"));
         } else {
             needsSplit = false;
             nodeType = type;
@@ -173,6 +169,7 @@
                 valid = false;
             }
         }
+
         if (!valid) {
             return null;
         }
@@ -213,7 +210,7 @@
                 nodeId = nodeId.substring(0, nodeId.length() - 4);
             }
             String newNodeId = nodeId + Utils.firstLetterUpperCase(id);
-            NodeData copy = new NodeData(node, newNodeId);
+            NodeData copy = new NodeData(node, id, newNodeId);
 
             copy.setSpecializations(specializations);
             copy.setSpecializationListeners(listeners);
@@ -221,10 +218,6 @@
             splitted.add(copy);
         }
 
-        if (splitted.isEmpty()) {
-            splitted.add(node);
-        }
-
         node.setSpecializations(new ArrayList<SpecializationData>());
         node.setSpecializationListeners(new ArrayList<SpecializationListenerData>());
 
@@ -460,18 +453,13 @@
             return null;
         }
 
-        TypeMirror typeSytemType = Utils.getAnnotationValueType(typeSystemMirror, "value");
+        TypeMirror typeSytemType = Utils.getAnnotationValue(TypeMirror.class, typeSystemMirror, "value");
         final TypeSystemData typeSystem = (TypeSystemData) context.getTemplate(typeSytemType, true);
         if (typeSystem == null) {
             log.error(templateType, "The used type system '%s' is invalid.", Utils.getQualifiedName(typeSytemType));
             return null;
         }
 
-        String nodeId = templateType.getSimpleName().toString();
-        if (nodeId.endsWith("Node") && !nodeId.equals("Node")) {
-            nodeId = nodeId.substring(0, nodeId.length() - 4);
-        }
-
         NodeData nodeData = new NodeData(templateType, typeSystem, templateType.getSimpleName().toString());
         nodeData.setNodeType(nodeType.asType());
 
@@ -479,7 +467,7 @@
 
         nodeData.setExecutableTypes(executableTypes);
 
-        parsedNodes.put(Utils.getQualifiedName(nodeType), nodeData);
+        parsedNodes.put(Utils.getQualifiedName(templateType), nodeData);
 
         List<NodeFieldData> fields = parseFields(nodeData, elements, typeHierarchy);
         if (fields == null) {
@@ -487,11 +475,6 @@
         }
         nodeData.setFields(fields);
 
-        if (!Utils.isAssignable(templateType.asType(), nodeType.asType())) {
-// nodeData.setInstanceParameterSpec(new ParameterSpec("instance", templateType.asType(), false,
-// true));
-        }
-
         return nodeData;
     }
 
@@ -626,8 +609,8 @@
         List<String> executionDefinition = null;
         if (executionOrderMirror != null) {
             executionDefinition = new ArrayList<>();
-            for (Object object : Utils.getAnnotationValueList(executionOrderMirror, "value")) {
-                executionDefinition.add((String) object);
+            for (String object : Utils.getAnnotationValueList(String.class, executionOrderMirror, "value")) {
+                executionDefinition.add(object);
             }
         }
 
@@ -635,7 +618,7 @@
         for (ExecutableElement method : ElementFilter.methodsIn(elements)) {
             AnnotationMirror mirror = Utils.findAnnotationMirror(processingEnv, method, ShortCircuit.class);
             if (mirror != null) {
-                shortCircuits.add(Utils.getAnnotationValueString(mirror, "value"));
+                shortCircuits.add(Utils.getAnnotationValue(String.class, mirror, "value"));
             }
         }