remove .item from tokenizer output

2 files changed, 27 insertions, 31 deletions

diff --git a/src/intertyper.js b/src/intertyper.js
index d0bb2b15..bfeed625 100644
--- a/src/intertyper.js
+++ b/src/intertyper.js
@@ -49,11 +49,7 @@ function tokenize(text, lineNum, indent) {
       text: text
     };
     if (text[0] in enclosers) {
-      if (text[0] !== '{') {
-        token.item = tokenize(text.substr(1, text.length-2));
-      } else {
-        token.tokens = tokenize(text.substr(1, text.length-2)).tokens;
-      }
+      token.tokens = tokenize(text.substr(1, text.length-2)).tokens;
       token.type = text[0];
     }
     // merge function definitions together
@@ -396,10 +392,10 @@ function intertyper(lines, sidePass, baseLineNums) {
             return { intertype: 'struct', type: segment[0].text, contents: handleSegments(segment[1].tokens) };
           } else if (segment[1].type && segment[1].type == '<') {
             Types.needAnalysis[segment[0].text] = 0;
-            return { intertype: 'struct', type: segment[0].text, contents: handleSegments(segment[1].item.tokens[0].tokens) };
+            return { intertype: 'struct', type: segment[0].text, contents: handleSegments(segment[1].tokens[0].tokens) };
           } else if (segment[1].type && segment[1].type == '[') {
             Types.needAnalysis[segment[0].text] = 0;
-            return { intertype: 'list', type: segment[0].text, contents: handleSegments(segment[1].item.tokens) };
+            return { intertype: 'list', type: segment[0].text, contents: handleSegments(segment[1].tokens) };
           } else if (segment.length == 2) {
             Types.needAnalysis[segment[0].text] = 0;
             return { intertype: 'value', type: segment[0].text, ident: toNiceIdent(segment[1].text) };
@@ -426,19 +422,19 @@ function intertyper(lines, sidePass, baseLineNums) {
         return { intertype: 'string', text: value.text.substr(1, value.text.length-2) };
       } else {
         if (value.type == '<') { // <{ i8 }> etc.
-          value = value.item.tokens;
+          value = value.tokens;
         }
         var contents;
-        if (value.item) {
+        if (value.type && value.type !== '{') {
           // list of items
-          contents = value.item.tokens;
+          contents = value.tokens;
         } else if (value.type == '{') {
           // struct
           contents = value.tokens;
         } else if (value[0]) {
           contents = value[0];
         } else {
-          throw '// interfailzzzzzzzzzzzzzz ' + dump(value.item) + ' ::: ' + dump(value);
+          throw '// interfailzzzzzzzzzzzzzz ' + dump(value);
         }
         return { intertype: 'segments', contents: handleSegments(contents) };
       }
@@ -471,7 +467,7 @@ function intertyper(lines, sidePass, baseLineNums) {
       } else if (item.tokens[1].text != 'opaque') {
         if (item.tokens[1].type == '<') {
           packed = true;
-          item.tokens[1] = item.tokens[1].item.tokens[0];
+          item.tokens[1] = item.tokens[1].tokens[0];
         }
         var subTokens = item.tokens[1].tokens;
         if (subTokens) {
@@ -514,8 +510,8 @@ function intertyper(lines, sidePass, baseLineNums) {
       noteGlobalVariable(ret);
       if (ident == '_llvm_global_ctors') {
         ret.ctors = [];
-        if (item.tokens[1].item) {
-          var subTokens = item.tokens[1].item.tokens;
+        var subTokens = item.tokens[1].tokens;
+        if (subTokens) {
           splitTokenList(subTokens).forEach(function(segment) {
             var parsed = parseLLVMSegment(segment);
             assert(parsed.intertype === 'structvalue');
@@ -549,7 +545,7 @@ function intertyper(lines, sidePass, baseLineNums) {
     item.tokens = item.tokens.filter(function(token) {
       return !(token.text in LLVM.LINKAGES || token.text in LLVM.PARAM_ATTR || token.text in LLVM.FUNC_ATTR || token.text in LLVM.CALLING_CONVENTIONS);
     });
-    var params = parseParamTokens(item.tokens[2].item.tokens);
+    var params = parseParamTokens(item.tokens[2].tokens);
     if (sidePass) dprint('unparsedFunctions', 'Processing function: ' + item.tokens[1].text);
     return {
       intertype: 'function',
@@ -634,9 +630,9 @@ function intertyper(lines, sidePass, baseLineNums) {
     while (!isType(item.tokens[first].text)) first++;
     Types.needAnalysis[item.tokens[first].text] = 0;
     var last = getTokenIndexByText(item.tokens, ';');
-    var segment = [ item.tokens[first], { text: 'getelementptr' }, null, { item: {
+    var segment = [ item.tokens[first], { text: 'getelementptr' }, null, {
       tokens: item.tokens.slice(first, last)
-    } } ];
+    } ];
     var data = parseLLVMFunctionCall(segment);
     item.intertype = 'getelementptr';
     item.type = '*'; // We need type info to determine this - all we know is it's a pointer
@@ -675,7 +671,7 @@ function intertyper(lines, sidePass, baseLineNums) {
       assert((item.tokens[5].text.match(/=/g) || []).length <= 1, 'we only support at most 1 exported variable from inline js: ' + item.ident);
       var i = 0;
       var params = [], args = [];
-      splitTokenList(tokensLeft[3].item.tokens).map(function(element) {
+      splitTokenList(tokensLeft[3].tokens).map(function(element) {
         var ident = toNiceIdent(element[1].text);
         var type = element[0].text;
         params.push('$' + (i++));
@@ -694,7 +690,7 @@ function intertyper(lines, sidePass, baseLineNums) {
       }
       item.params = [];
     } else {
-      item.params = parseParamTokens(tokensLeft[0].item.tokens);
+      item.params = parseParamTokens(tokensLeft[0].tokens);
     }
     item.ident = toNiceIdent(item.ident);
     if (type === 'invoke') {
@@ -785,7 +781,7 @@ function intertyper(lines, sidePass, baseLineNums) {
     Types.needAnalysis[item.type] = 0;
     var last = getTokenIndexByText(item.tokens, ';');
     item.params = splitTokenList(item.tokens.slice(2, last)).map(function(segment) {
-      var subSegments = splitTokenList(segment[0].item.tokens);
+      var subSegments = splitTokenList(segment[0].tokens);
       var ret = {
         intertype: 'phiparam',
         label: toNiceIdent(subSegments[1][0].text),
@@ -923,7 +919,7 @@ function intertyper(lines, sidePass, baseLineNums) {
   function switchHandler(item) {
     function parseSwitchLabels(item) {
       var ret = [];
-      var tokens = item.item.tokens;
+      var tokens = item.tokens;
       while (tokens.length > 0) {
         ret.push({
           value: tokens[1].text,
@@ -956,7 +952,7 @@ function intertyper(lines, sidePass, baseLineNums) {
     while (item.tokens[1].text in LLVM.LINKAGES || item.tokens[1].text in LLVM.PARAM_ATTR || item.tokens[1].text in LLVM.VISIBILITIES || item.tokens[1].text in LLVM.CALLING_CONVENTIONS) {
       item.tokens.splice(1, 1);
     }
-    var params = parseParamTokens(item.tokens[3].item.tokens);
+    var params = parseParamTokens(item.tokens[3].tokens);
     return {
       intertype: 'functionStub',
       ident: toNiceIdent(item.tokens[2].text),
diff --git a/src/parseTools.js b/src/parseTools.js
index 3856c17e..bc151843 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -230,9 +230,9 @@ function isFunctionDef(token, out) {
   if (nonPointing[0] != '(' || nonPointing.substr(-1) != ')')
     return false;
   if (nonPointing === '()') return true;
-  if (!token.item) return false;
+  if (!token.tokens) return false;
   var fail = false;
-  var segments = splitTokenList(token.item.tokens);
+  var segments = splitTokenList(token.tokens);
   segments.forEach(function(segment) {
     var subtext = segment[0].text;
     fail = fail || segment.length > 1 || !(isType(subtext) || subtext == '...');
@@ -280,7 +280,7 @@ function isFunctionType(type, out) {
     i--;
   }
   assert(argText);
-  return isFunctionDef({ text: argText, item: tokenize(argText.substr(1, argText.length-2)) }, out);
+  return isFunctionDef({ text: argText, tokens: tokenize(argText.substr(1, argText.length-2)).tokens }, out);
 }
 
 function getReturnType(type) {
@@ -615,13 +615,13 @@ function parseLLVMFunctionCall(segment) {
   segment = cleanSegment(segment);
   // Remove additional modifiers
   var variant = null;
-  if (!segment[2] || !segment[2].item) {
+  if (!segment[2] || !segment[2].tokens) {
     variant = segment.splice(2, 1)[0];
     if (variant && variant.text) variant = variant.text; // needed for mathops
   }
   assertTrue(['inreg', 'byval'].indexOf(segment[1].text) == -1);
   assert(segment[1].text in PARSABLE_LLVM_FUNCTIONS);
-  while (!segment[2].item) {
+  while (!segment[2].tokens) {
     segment.splice(2, 1); // Remove modifiers
     if (!segment[2]) throw 'Invalid segment!';
   }
@@ -630,15 +630,15 @@ function parseLLVMFunctionCall(segment) {
   if (type === '?') {
     if (intertype === 'getelementptr') {
       type = '*'; // a pointer, we can easily say, this is
-    } else if (segment[2].item.tokens.slice(-2)[0].text === 'to') {
-      type = segment[2].item.tokens.slice(-1)[0].text;
+    } else if (segment[2].tokens.slice(-2)[0].text === 'to') {
+      type = segment[2].tokens.slice(-1)[0].text;
     }
   }
   var ret = {
     intertype: intertype,
     variant: variant,
     type: type,
-    params: parseParamTokens(segment[2].item.tokens)
+    params: parseParamTokens(segment[2].tokens)
   };
   Types.needAnalysis[ret.type] = 0;
   ret.ident = toNiceIdent(ret.params[0].ident || 'NOIDENT');
@@ -2493,7 +2493,7 @@ function walkAndModifyInterdata(item, pre) {
 }
 
 function parseBlockAddress(segment) {
-  return { intertype: 'blockaddress', func: toNiceIdent(segment[2].item.tokens[0].text), label: toNiceIdent(segment[2].item.tokens[2].text), type: 'i32' };
+  return { intertype: 'blockaddress', func: toNiceIdent(segment[2].tokens[0].text), label: toNiceIdent(segment[2].tokens[2].text), type: 'i32' };
 }
 
 function finalizeBlockAddress(param) {