finish code generator revamp, output is now much nicer and liberal with it's use of newlines

lib/babel/generation/buffer.js

@@ -86,7 +86,7 @@ Buffer.prototype.newline = function (i, removeLast) {
   if (isNumber(i)) {
     i = Math.min(2, i);
 
-    if (this.endsWith("{\n")) i--;
+    if (this.endsWith("{\n") || this.endsWith(":\n")) i--;
     if (i <= 0) return;
 
     while (i > 0) {

lib/babel/generation/generators/statements.js

@@ -149,6 +149,7 @@ exports.SwitchStatement = function (node, print) {
   this.space();
   this.push("{");
   print.sequence(node.cases, { indent: true });
+  this.removeLast("\n");
   this.push("}");
 };
 
@@ -161,8 +162,10 @@ exports.SwitchCase = function (node, print) {
     this.push("default:");
   }
 
-  this.newline();
-  print.sequence(node.consequent, { indent: true });
+  if (node.consequent.length) {
+    this.newline();
+    print.sequence(node.consequent, { indent: true });
+  }
 };
 
 exports.DebuggerStatement = function () {

lib/babel/generation/node/whitespace.js

@@ -5,23 +5,51 @@ var each      = require("lodash/collection/each");
 var map       = require("lodash/collection/map");
 var t         = require("../../types");
 
-var shouldWhitespace = function (node) {
-  if (t.isFunction(node)) {
-    return true;
-  } else if (t.isAssignmentExpression(node)) {
-    return shouldWhitespace(node.right);
-  } else if (t.isBinary(node)) {
-    return shouldWhitespace(node.left) || shouldWhitespace(node.right);
+var crawl = function (node, state) {
+  state = state || {};
+
+  if (t.isMemberExpression(node)) {
+    crawl(node.object, state);
+    if (node.computed) crawl(node.property, state);
+  } else if (t.isBinary(node) || t.isAssignmentExpression(node)) {
+    crawl(node.left, state);
+    crawl(node.right, state);
+  } else if (t.isCallExpression(node)) {
+    state.hasCall = true;
+    crawl(node.callee, state);
+  } else if (t.isFunction(node)) {
+    state.hasFunction = true;
+  } else if (t.isIdentifier(node)) {
+    state.hasHelper = state.hasHelper || isHelper(node.callee);
   }
 
-  return false;
+  return state;
+};
+
+var isHelper = function (node) {
+  if (t.isMemberExpression(node)) {
+    return isHelper(node.object) || isHelper(node.property);
+  } else if (t.isIdentifier(node)) {
+    return node.name === "require" || node.name[0] === "_";
+  } else if (t.isCallExpression(node)) {
+    return isHelper(node.callee);
+  } else if (t.isBinary(node) || t.isAssignmentExpression(node)) {
+    return (t.isIdentifier(node.left) && isHelper(node.left)) || isHelper(node.right);
+  } else {
+    return false;
+  }
+};
+
+var isType = function (node) {
+  return t.isLiteral(node) || t.isObjectExpression(node) || t.isArrayExpression(node) || t.isIdentifier(node) || t.isMemberExpression(node);
 };
 
 exports.nodes = {
   AssignmentExpression: function (node) {
-    if (shouldWhitespace(node.right)) {
+    var state = crawl(node.right);
+    if ((state.hasCall && state.hasHelper) || state.hasFunction) {
       return {
-        before: true,
+        before: state.hasFunction,
         after: true
       };
     }
@@ -52,7 +80,7 @@ exports.nodes = {
   },
 
   CallExpression: function (node) {
-    if (t.isFunction(node.callee)) {
+    if (t.isFunction(node.callee) || isHelper(node)) {
       return {
         before: true,
         after: true
@@ -63,14 +91,29 @@ exports.nodes = {
   VariableDeclaration: function (node) {
     for (var i = 0; i < node.declarations.length; i++) {
       var declar = node.declarations[i];
-      var init   = declar.init;
-      if (!t.isIdentifier(init) && shouldWhitespace(init)) {
+
+      var enabled = isHelper(declar.id) && !isType(declar.init);
+      if (!enabled) {
+        var state = crawl(declar.init);
+        enabled = (isHelper(declar.init) && state.hasCall) || state.hasFunction;
+      }
+
+      if (enabled) {
         return {
           before: true,
           after: true
         };
       }
     }
+  },
+
+  IfStatement: function (node) {
+    if (t.isBlockStatement(node.consequent)) {
+      return {
+        before: true,
+        after: true
+      };
+    }
   }
 };
 
@@ -103,8 +146,7 @@ each({
   Loop: true,
   LabeledStatement: true,
   SwitchStatement: true,
-  TryStatement: true,
-  IfStatement: true
+  TryStatement: true
 }, function (amounts, type) {
   if (isBoolean(amounts)) {
     amounts = { after: amounts, before: amounts };