Clean up static const usage, misc cleanup

Clang can't determine for some integral static const that their address
hasn't been taken or that nothing makes an lvalue pointer to them, so we
need to redeclare them in the cpp file to satisfy the linker. Did this
somewhat inconsistently for the cases where clang complained.

Author: digitalinfinity

lib/Common/Common/NumberUtilities.cpp

@@ -9,6 +9,29 @@
 
 namespace Js
 {
+    // Redeclare static constants
+    const UINT64 NumberConstantsBase::k_Nan;
+    const INT64 NumberUtilitiesBase::Pos_InvalidInt64;
+    const INT64 NumberUtilitiesBase::Neg_InvalidInt64;
+    const uint64 NumberConstants::k_PosInf;
+    const uint64 NumberConstants::k_NegInf;
+    const uint64 NumberConstants::k_PosMin;
+    const uint64 NumberConstants::k_PosMax;
+    const uint64 NumberConstants::k_NegZero;
+    const uint64 NumberConstants::k_Zero;
+    const uint64 NumberConstants::k_PointFive;
+    const uint64 NumberConstants::k_NegPointFive;
+    const uint64 NumberConstants::k_NegOne;
+    const uint64 NumberConstants::k_OnePointZero;
+    const uint64 NumberConstants::k_TwoToFraction;
+    const uint64 NumberConstants::k_NegTwoToFraction;
+    const uint32 NumberConstants::k_Float32Zero;
+    const uint32 NumberConstants::k_Float32PointFive;
+    const uint32 NumberConstants::k_Float32NegPointFive;
+    const uint32 NumberConstants::k_Float32NegZero;
+    const uint32 NumberConstants::k_Float32TwoToFraction;
+    const uint32 NumberConstants::k_Float32NegTwoToFraction;
+
     const double NumberConstants::MAX_VALUE = *(double*)(&NumberConstants::k_PosMax);
     const double NumberConstants::MIN_VALUE = *(double*)(&NumberConstants::k_PosMin);
     const double NumberConstants::NaN = *(double*)(&NumberConstants::k_Nan);

lib/Common/DataStructures/BigInt.cpp

@@ -591,20 +591,6 @@ namespace Js
         return dbl;
     }
 
-    namespace // anonymous
-    {
-        template <typename EncodedChar>
-        void Reference(void)
-        {
-            BigInt i;
-            i.FInitFromDigits<EncodedChar>(NULL, 0, NULL);
-        }
-
-        void Instantiations(void)
-        {
-            Reference<char16>();
-            Reference<utf8char_t>();
-        }
-    }
-
+    template bool BigInt::FInitFromDigits<char16>(const char16 *prgch, long cch, long *pcchDig);
+    template bool BigInt::FInitFromDigits<utf8char_t>(const utf8char_t *prgch, long cch, long *pcchDig);
 }

lib/Parser/CharSet.cpp

@@ -1870,4 +1870,11 @@ namespace UnifiedRegex
     }
 #endif
 
+    const int  CharSetNode::directBits;
+    const uint CharSetNode::directSize;
+    const uint CharSetNode::innerMask;
+    const int  CharSetNode::bitsPerLeafLevel;
+    const int  CharSetNode::branchingPerLeafLevel;
+    const uint CharSetNode::leafMask;
+    const uint CharSetNode::levels;
 }

lib/Parser/RegexCompileTime.cpp

@@ -11,6 +11,8 @@ namespace UnifiedRegex
     // Compiler (inlines etc)
     // ----------------------------------------------------------------------
 
+    const CharCount Compiler::initInstBufSize;
+
     uint8* Compiler::Emit(size_t size)
     {
         Assert(size <= UINT32_MAX);

lib/Parser/RegexParser.cpp

@@ -104,6 +104,9 @@ Term ::= ... | '(' '?' '=' Disjunction ')' [removed] | '(' '?' '!' Disjunction '
 
 namespace UnifiedRegex
 {
+    template <typename P, const bool IsLiteral>
+    const CharCount Parser<P, IsLiteral>::initLitbufSize;
+
     ParseError::ParseError(bool isBody, CharCount pos, CharCount encodedPos, HRESULT error)
         : isBody(isBody), pos(pos), encodedPos(encodedPos), error(error)
     {
@@ -3055,45 +3058,20 @@ namespace UnifiedRegex
         }
     }
 
-    //
-    // Template instantiation
-    //
-
-    template <typename P, const bool IsLiteral>
-    void UnifiedRegexParserForceInstantiation()
-    {
-        typedef typename P::EncodedChar EncodedChar;
-        Parser<P, IsLiteral> p
-            ( 0
-            , 0
-            , 0
-            , 0
-            , false
-#if ENABLE_REGEX_CONFIG_OPTIONS
-            , 0
-#endif
-            );
-
-        RegexFlags f;
-        CharCount a, b, c, d;
-        const EncodedChar* cp = 0;
-        p.ParseDynamic(0, 0, 0, 0, f);
-        p.ParseLiteral(0, 0, a, b, c, d, f);
-        p.ParseLiteralNoAST(0, 0, a, b, c, d);
-        p.template CompileProgram<true>(0, cp, a, b, c, f);
-        p.template CompileProgram<false>(0, cp, a, b, c, f);
-        p.CaptureEmptySourceAndNoGroups(0);
-        p.CaptureSourceAndGroups(0, 0, 0, 0);
-        p.FreeBody();
-    }
-
-    void UnifiedRegexParserForceAllInstantiations()
-    {
-        UnifiedRegexParserForceInstantiation<NullTerminatedUnicodeEncodingPolicy, false>();
-        UnifiedRegexParserForceInstantiation<NullTerminatedUnicodeEncodingPolicy, true>();
-        UnifiedRegexParserForceInstantiation<NullTerminatedUTF8EncodingPolicy, false>();
-        UnifiedRegexParserForceInstantiation<NullTerminatedUTF8EncodingPolicy, true>();
-        UnifiedRegexParserForceInstantiation<NotNullTerminatedUTF8EncodingPolicy, false>();
-        UnifiedRegexParserForceInstantiation<NotNullTerminatedUTF8EncodingPolicy, true>();
-    }
+    // Instantiate all templates
+#define INSTANTIATE_REGEX_PARSER_COMPILE(EncodingPolicy, IsLiteral, BuildAST)    \
+    template RegexPattern* Parser<EncodingPolicy, IsLiteral>::CompileProgram<BuildAST>(Node* root, const EncodedChar*& currentCharacter, const CharCount totalLen, const CharCount bodyChars, const CharCount totalChars, const RegexFlags flags );
+
+#define INSTANTIATE_REGEX_PARSER(EncodingPolicy)                     \
+    INSTANTIATE_REGEX_PARSER_COMPILE(EncodingPolicy, false, false)   \
+    INSTANTIATE_REGEX_PARSER_COMPILE(EncodingPolicy, false, true)    \
+    INSTANTIATE_REGEX_PARSER_COMPILE(EncodingPolicy, true, false)    \
+    INSTANTIATE_REGEX_PARSER_COMPILE(EncodingPolicy, true, true)     \
+    template class Parser<EncodingPolicy, false>;                    \
+    template class Parser<EncodingPolicy, true>;
+
+    // Instantiate the Parser
+    INSTANTIATE_REGEX_PARSER(NullTerminatedUnicodeEncodingPolicy);
+    INSTANTIATE_REGEX_PARSER(NullTerminatedUTF8EncodingPolicy);
+    INSTANTIATE_REGEX_PARSER(NotNullTerminatedUTF8EncodingPolicy);
 }

lib/Runtime/Base/Constants.cpp

@@ -6,6 +6,9 @@
 
 using namespace Js;
 
+const uint Constants::InvalidSourceIndex;
+const RegSlot Constants::NoRegister;
+
 const char16 Constants::AnonymousFunction[] = _u("Anonymous function");
 const char16 Constants::Anonymous[] = _u("anonymous");
 const char16 Constants::Empty[] = _u("");

lib/Runtime/Base/FunctionBody.cpp

@@ -33,6 +33,8 @@
 
 namespace Js
 {
+    uint const ScopeSlots::MaxEncodedSlotCount;
+
     CriticalSection FunctionProxy::GlobalLock;
 
 #ifdef FIELD_ACCESS_STATS

lib/Runtime/Library/ConcatString.cpp

@@ -119,6 +119,9 @@ namespace Js
 
     /////////////////////// ConcatStringBuilder //////////////////////////
 
+    // MAX number of slots in one chunk. Until we fit into this, we realloc, otherwise create new chunk.
+    const int ConcatStringBuilder::c_maxChunkSlotCount;
+
     ConcatStringBuilder::ConcatStringBuilder(ScriptContext* scriptContext, int initialSlotCount) :
         ConcatStringBase(scriptContext->GetLibrary()->GetStringTypeStatic()),
         m_count(0), m_prevChunk(NULL)

lib/Runtime/Library/JavascriptFunction.cpp

@@ -22,6 +22,8 @@ extern "C" void __cdecl _alloca_probe_16();
 
 namespace Js
 {
+    const charcount_t JavascriptFunction::DIAG_MAX_FUNCTION_STRING;
+
     DEFINE_RECYCLER_TRACKER_PERF_COUNTER(JavascriptFunction);
     JavascriptFunction::JavascriptFunction(DynamicType * type)
         : DynamicObject(type), functionInfo(nullptr), constructorCache(&ConstructorCache::DefaultInstance)

lib/Runtime/Library/JavascriptRegExpConstructor.cpp

@@ -7,6 +7,8 @@
 
 namespace Js
 {
+    const int JavascriptRegExpConstructor::NumCtorCaptures;
+
     JavascriptRegExpConstructor::JavascriptRegExpConstructor(DynamicType * type) :
         RuntimeFunction(type, &JavascriptRegExp::EntryInfo::NewInstance),
         reset(false),