Fix template angle bracket syntax

Source/wtf/TypeTraits.cpp

  /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 158 matching lines @@
 static_assert(IsConvertibleToInteger<unsigned long long>::value, "unsigned long long should be convertible to integer");
 #if !COMPILER(MSVC) || defined(_NATIVE_WCHAR_T_DEFINED)
 static_assert(IsConvertibleToInteger<wchar_t>::value, "whcar_t should be convertible to integer");
 #endif
 static_assert(IsConvertibleToInteger<double>::value, "double should be convertible to integer");
 static_assert(IsConvertibleToInteger<long double>::value, "long double should be convertible to integer");
 static_assert(IsConvertibleToInteger<float>::value, "float should be convertible to integer");
 static_assert(!IsConvertibleToInteger<char*>::value, "char* should not be convertible to integer");
 static_assert(!IsConvertibleToInteger<const char*>::value, "const char* should not be convertible to integer");
 static_assert(!IsConvertibleToInteger<volatile char*>::value, "volatile char* should not be convertible to integer");
-static_assert(!IsConvertibleToInteger<IsConvertibleToInteger<bool> >::value, "struct should not be convertible to integer");
+static_assert(!IsConvertibleToInteger<IsConvertibleToInteger<bool>>::value, "struct should not be convertible to integer");
 
 static_assert((IsPointerConvertible<int, int>::Value), "pointers to the same type should be convertible");
 static_assert((!IsPointerConvertible<int, unsigned>::Value), "int pointers should not be convertible to unsigned pointers");
 static_assert((IsPointerConvertible<int, const int>::Value), "int pointers should be convertible to const int pointers");
 static_assert((!IsPointerConvertible<const int, int>::Value), "const int* should not be convertible to int*");
 static_assert((IsPointerConvertible<int, volatile int>::Value), "int* should be convertible to volatile int*");
 
 static_assert((IsSameType<bool, bool>::value), "bool should be the same type as itself");
 static_assert((IsSameType<int*, int*>::value), "int* should be the same type as itself");
 static_assert((!IsSameType<int, int*>::value), "int should not be the same type as int*");
 static_assert((!IsSameType<bool, const bool>::value), "T should not be the same type as const T");
 static_assert((!IsSameType<bool, volatile bool>::value), "T should not be the same type as volatile T");
 
 template <typename T>
 class TestBaseClass {
 };
 
 class TestDerivedClass : public TestBaseClass<int> {
 };
 
-static_assert((IsSubclass<TestDerivedClass, TestBaseClass<int> >::value), "Derived class should be a subclass of its base");
+static_assert((IsSubclass<TestDerivedClass, TestBaseClass<int>>::value), "Derived class should be a subclass of its base");
 static_assert((!IsSubclass<TestBaseClass<int>, TestDerivedClass>::value), "Base class should not be a sublass of a derived class");
 static_assert((IsSubclassOfTemplate<TestDerivedClass, TestBaseClass>::value), "Derived class should be a subclass of template from its base");
 static_assert((IsSameType<RemoveTemplate<TestBaseClass<int>, TestBaseClass>::Type, int>::value), "RemoveTemplate should remove the template typename from the type");
 static_assert((IsSameType<RemoveTemplate<int, TestBaseClass>::Type, int>::value), "RemoveTemplate should not alter non-template types");
-static_assert((IsPointerConvertible<TestDerivedClass, TestBaseClass<int> >::Value), "Derived class pointers should be convertible to base class pointers");
+static_assert((IsPointerConvertible<TestDerivedClass, TestBaseClass<int>>::Value), "Derived class pointers should be convertible to base class pointers");
 static_assert((!IsPointerConvertible<TestBaseClass<int>, TestDerivedClass>::Value), "Base class pointers should not be convertible to derived class pointers");
 
 static_assert((IsSameType<bool, RemoveConst<const bool>::Type>::value), "RemoveConst should produce the corresponding non-const type");
 static_assert((!IsSameType<bool, RemoveConst<volatile bool>::Type>::value), "RemoveConst of volatile types should not remove volatility");
 
 static_assert((IsSameType<bool, RemoveVolatile<bool>::Type>::value), "RemoveVolatile should not modify the type of non-volatile types");
 static_assert((!IsSameType<bool, RemoveVolatile<const bool>::Type>::value), "RemoveVolatile should not remove const-ness");
 static_assert((IsSameType<bool, RemoveVolatile<volatile bool>::Type>::value), "RemoveVolatile should produce the equivalent non-volatile type");
 
 static_assert((IsSameType<bool, RemoveConstVolatile<bool>::Type>::value), "RemoveConstVolatile should not modify the type of non-const non-volatile types");
@@ skipping 12 matching lines @@
 typedef int IntArray[];
 typedef int IntArraySized[4];
 
 static_assert((IsArray<IntArray>::value), "IsArray should recognize arrays");
 static_assert((IsArray<IntArraySized>::value), "IsArray should recognize sized arrays");
 
 static_assert((IsSameType<int, RemoveExtent<IntArray>::Type>::value), "RemoveExtent should return the array element type of an array");
 static_assert((IsSameType<int, RemoveExtent<IntArraySized>::Type>::value), "RemoveExtent should return the array element type of a sized array");
 
 } // namespace WTF