Addressing feedback and general cleanup

**Changes**
 * Remove `Symbol.toStringTag` from the classes themselves, leaving only
 the prototype application
 * Refactor the injection of the symbols to a reusable utility in
 jsUtils.
 * Write new tests for the utility functions
 * Update tests for the classes receiving Symbol.toStringTag

Author: Brielle Harrison

package-lock.json

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+import { hasSymbolSupport, applyToStringTag } from '../symbolSupport';
+
+describe('symbolSupportTests', () => {
+  // NOTE Symbol appeared in nodejs in 0.12.18 but was largely unusable in
+  // that format. Symbol.toStringTag showed up in node 6.4.0, but was available
+  // behind a flag as early as 4.9.1.
+  const [, major, minor, patch] = /^v(\d+)\.?(\d+)?\.?(\d+)?/.exec(
+    process.version,
+  );
+
+  it('should have Symbol in scope if the version >= 0.12.18', () => {
+    expect(major >= 4).to.equal(true);
+
+    if (major === 4) {
+      expect(minor >= 9).to.equal(true);
+    }
+
+    if (minor === 9) {
+      expect(patch >= 1).to.equal(true);
+    }
+
+    expect(hasSymbolSupport()).to.equal(true);
+  });
+
+  it('should have Symbol in scope if the version >= 0.12.18', () => {
+    expect(major >= 6).to.equal(true);
+
+    if (major === 6) {
+      expect(minor >= 4).to.equal(true);
+    }
+
+    if (minor === 4) {
+      expect(patch >= 0).to.equal(true);
+    }
+
+    expect(typeof Symbol !== 'undefined').to.equal(true);
+    expect(hasSymbolSupport('toStringTag')).to.equal(true);
+  });
+
+  it('should be able to apply toStringTag to a class', () => {
+    class A {}
+    applyToStringTag(A);
+
+    const a = new A();
+
+    expect(Object.prototype.toString.call(a)).to.equal('[object A]');
+    expect(Object.prototype.toString.call(A)).not.to.equal('[object A]');
+  });
+});

src/jsutils/__tests__/symbolSupport-test.js

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ */
+
+/**
+ * A function that can either simply determine if `Symbol`s are allowed as
+ * well as, optionally, determine whether or not a property of symbol
+ * exists.
+ *
+ * If the name of a specific `Symbol` property is supplied, the resulting
+ * value will only be true if property is mapped to an instance of `Symbol`
+ * such as `.toStringTag`, `.iterator`, `.species`, `.isConcatSpreadable`,
+ * etc...
+ *
+ * @method hasSymbolSupport
+ *
+ * @param {string}  specificSymbol an optional name of a property on the
+ * `Symbol` class itself that statically refers to a predefined `Symbol`. If
+ * properly specified and the value is set, then true will be returned.
+ * @return {bool} true if `Symbol` is both defined and a function. Optionally
+ * true if the `Symbol` class is true, a predefined symbol name such as
+ * `toStringTag` is set on the `Symbol` class and it maps to an instance of
+ * `Symbol`. False in all other cases
+ */
+export function hasSymbolSupport(specificSymbol?: string): boolean {
+  const hasSymbols: boolean = typeof Symbol === 'function';
+
+  if (!hasSymbols) {
+    return false;
+  }
+
+  if (specificSymbol) {
+    // NOTE: The capture of type and string comparison over a few lines is
+    // necessary to appease the lint and flowtype gods.
+    //
+    // ((typeof Symbol[specificSymbol]): string) !== 'symbol' makes lint angry
+    // and typeof Symbol[specificSymbol] !== 'symbol' makes flow angry
+    //
+    // The former thinks everything is too verbose the later thinks I am
+    // comparing Symbol instance rather than the string resulting from a call
+    // to typeof.
+    //
+    // Le sigh....
+    const type: string = typeof Symbol[specificSymbol];
+
+    if (type !== 'symbol') {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * The `applyToStringTag()` function checks first to see if the runtime
+ * supports the `Symbol` class and then if the `Symbol.toStringTag` constant
+ * is defined as a `Symbol` instance. If both conditions are met, the
+ * Symbol.toStringTag property is defined as a getter that returns the
+ * supplied class constructor's name.
+ *
+ * @method applyToStringTag
+ *
+ * @param {Class<*>} classObject a class such as Object, String, Number but
+ * typically one of your own creation through the class keyword; `class A {}`,
+ * for example.
+ */
+export function applyToStringTag(classObject: Class<*>): void {
+  if (hasSymbolSupport('toStringTag')) {
+    Object.defineProperty(classObject.prototype, Symbol.toStringTag, {
+      get() {
+        return this.constructor.name;
+      },
+    });
+  }
+}

src/jsutils/symbolSupport.js

@@ -8,6 +8,7 @@
  */
 
 import invariant from '../jsutils/invariant';
+import { applyToStringTag } from '../jsutils/symbolSupport';
 
 type Location = {
   line: number,
@@ -42,14 +43,5 @@ export class Source {
   }
 }
 
-Object.defineProperty(Source, Symbol.toStringTag, {
-  get() {
-    return this.name;
-  },
-});
-
-Object.defineProperty(Source.prototype, Symbol.toStringTag, {
-  get() {
-    return this.constructor.name;
-  },
-});
+// Conditionally apply `[Symbol.toStringTag]` if `Symbol`s are supported
+applyToStringTag(Source);