Script-based imports should basically work

sky/engine/wtf/HashMap.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011 Apple 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,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 40 matching lines @@
         typename Allocator = DefaultAllocator>
     class HashMap {
         WTF_USE_ALLOCATOR(HashMap, Allocator);
     private:
         typedef KeyTraitsArg KeyTraits;
         typedef MappedTraitsArg MappedTraits;
         typedef HashMapValueTraits<KeyTraits, MappedTraits> ValueTraits;
 
     public:
         typedef typename KeyTraits::TraitType KeyType;
+        typedef typename KeyTraits::PassInType KeyPassInType;
         typedef const typename KeyTraits::PeekInType& KeyPeekInType;
         typedef typename MappedTraits::TraitType MappedType;
         typedef typename ValueTraits::TraitType ValueType;
 
     private:
         typedef typename MappedTraits::PassInType MappedPassInType;
         typedef typename MappedTraits::PassOutType MappedPassOutType;
         typedef typename MappedTraits::PeekOutType MappedPeekType;
 
         typedef typename ReferenceTypeMaker<MappedPassInType>::ReferenceType MappedPassInReferenceType;
@@ skipping 40 matching lines @@
         const HashMapValuesProxy& values() const { return static_cast<const HashMapValuesProxy&>(*this); }
 
         iterator find(KeyPeekInType);
         const_iterator find(KeyPeekInType) const;
         bool contains(KeyPeekInType) const;
         MappedPeekType get(KeyPeekInType) const;
 
         // replaces value but not key if key is already present
         // return value is a pair of the iterator to the key location,
         // and a boolean that's true if a new value was actually added
-        AddResult set(KeyPeekInType, MappedPassInType);
+        AddResult set(KeyPassInType, MappedPassInType);
 
         // does nothing if key is already present
         // return value is a pair of the iterator to the key location,
         // and a boolean that's true if a new value was actually added
-        AddResult add(KeyPeekInType, MappedPassInType);
+        AddResult add(KeyPassInType, MappedPassInType);
 
         void remove(KeyPeekInType);
         void remove(iterator);
         void clear();
         template<typename Collection>
         void removeAll(const Collection& toBeRemoved) { WTF::removeAll(*this, toBeRemoved); }
 
         MappedPassOutType take(KeyPeekInType); // efficient combination of get with remove
 
         // An alternate version of find() that finds the object by hashing and comparing
@@ skipping 11 matching lines @@
         //   static unsigned hash(const T&);
         //   static bool equal(const ValueType&, const T&);
         //   static translate(ValueType&, const T&, unsigned hashCode);
         template<typename HashTranslator, typename T> AddResult add(const T&, MappedPassInType);
 
         static bool isValidKey(KeyPeekInType);
 
         void trace(typename Allocator::Visitor* visitor) { m_impl.trace(visitor); }
 
     private:
-        AddResult inlineAdd(KeyPeekInType, MappedPassInReferenceType);
+        AddResult inlineAdd(KeyPassInType, MappedPassInReferenceType);
 
         HashTableType m_impl;
     };
 
     template<typename KeyArg, typename MappedArg, typename HashArg, typename KeyTraitsArg, typename MappedTraitsArg, typename Allocator>
     class HashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg, Allocator>::HashMapKeysProxy :
         private HashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg, Allocator> {
         public:
             typedef HashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg, Allocator> HashMapType;
             typedef typename HashMapType::iterator::Keys iterator;
@@ skipping 176 matching lines @@
     template<typename T, typename U, typename V, typename W, typename X, typename Y>
     template<typename HashTranslator, typename TYPE>
     inline bool
     HashMap<T, U, V, W, X, Y>::contains(const TYPE& value) const
     {
         return m_impl.template contains<HashMapTranslatorAdapter<ValueTraits, HashTranslator> >(value);
     }
 
     template<typename T, typename U, typename V, typename W, typename X, typename Y>
     typename HashMap<T, U, V, W, X, Y>::AddResult
-    HashMap<T, U, V, W, X, Y>::inlineAdd(KeyPeekInType key, MappedPassInReferenceType mapped)
+    HashMap<T, U, V, W, X, Y>::inlineAdd(KeyPassInType key, MappedPassInReferenceType mapped)
     {
         return m_impl.template add<HashMapTranslator<ValueTraits, HashFunctions> >(key, mapped);
     }
 
     template<typename T, typename U, typename V, typename W, typename X, typename Y>
     typename HashMap<T, U, V, W, X, Y>::AddResult
-    HashMap<T, U, V, W, X, Y>::set(KeyPeekInType key, MappedPassInType mapped)
+    HashMap<T, U, V, W, X, Y>::set(KeyPassInType key, MappedPassInType mapped)
     {
         AddResult result = inlineAdd(key, mapped);
         if (!result.isNewEntry) {
             // The inlineAdd call above found an existing hash table entry; we need to set the mapped value.
             MappedTraits::store(mapped, result.storedValue->value);
         }
         return result;
     }
 
     template<typename T, typename U, typename V, typename W, typename X, typename Y>
     template<typename HashTranslator, typename TYPE>
     typename HashMap<T, U, V, W, X, Y>::AddResult
     HashMap<T, U, V, W, X, Y>::add(const TYPE& key, MappedPassInType value)
     {
         return m_impl.template addPassingHashCode<HashMapTranslatorAdapter<ValueTraits, HashTranslator> >(key, value);
     }
 
     template<typename T, typename U, typename V, typename W, typename X, typename Y>
     typename HashMap<T, U, V, W, X, Y>::AddResult
-    HashMap<T, U, V, W, X, Y>::add(KeyPeekInType key, MappedPassInType mapped)
+    HashMap<T, U, V, W, X, Y>::add(KeyPassInType key, MappedPassInType mapped)
     {
         return inlineAdd(key, mapped);
     }
 
     template<typename T, typename U, typename V, typename W, typename X, typename Y>
     typename HashMap<T, U, V, W, X, Y>::MappedPeekType
     HashMap<T, U, V, W, X, Y>::get(KeyPeekInType key) const
     {
         ValueType* entry = const_cast<HashTableType&>(m_impl).lookup(key);
         if (!entry)
@@ skipping 104 matching lines @@
 struct NeedsTracing<HashMap<T, U, V, W, X> > {
     static const bool value = false;
 };
 #endif
 
 } // namespace WTF
 
 using WTF::HashMap;
 
 #endif /* WTF_HashMap_h */