Mark single-argument inline constructors as 'explicit'.

src/objects.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 149 matching lines @@
     value_ = TypeField::encode(type)
         | AttributesField::encode(attributes)
         | StorageField::encode(static_cast<int>(array_type));
 
     ASSERT(type == this->type());
     ASSERT(attributes == this->attributes());
     ASSERT(array_type == this->array_type());
   }
 
   // Conversion for storing details as Object*.
-  inline PropertyDetails(Smi* smi);
+  explicit inline PropertyDetails(Smi* smi);
   inline Smi* AsSmi();
 
   PropertyType type() { return TypeField::decode(value_); }
 
   bool IsTransition() {
     PropertyType t = type();
     ASSERT(t != INTERCEPTOR);
     return t == MAP_TRANSITION || t == CONSTANT_TRANSITION ||
         t == EXTERNAL_ARRAY_TRANSITION;
   }
@@ skipping 2388 matching lines @@
     Print(stdout);
   }
   void Print(FILE* out);
 #endif
   // Returns the key (slow).
   Object* SlowReverseLookup(Object* value);
 
   // Sets the entry to (key, value) pair.
   inline void SetEntry(int entry,
                        Object* key,
+                       Object* value);
+  inline void SetEntry(int entry,
+                       Object* key,
                        Object* value,
                        PropertyDetails details);
-
+  
   MUST_USE_RESULT MaybeObject* Add(Key key,
                                    Object* value,
                                    PropertyDetails details);
 
  protected:
   // Generic at put operation.
   MUST_USE_RESULT MaybeObject* AtPut(Key key, Object* value);
 
   // Add entry to dictionary.
   MUST_USE_RESULT MaybeObject* AddEntry(Key key,
@@ skipping 2559 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(CodeCacheHashTable);
 };
 
 
 enum AllowNullsFlag {ALLOW_NULLS, DISALLOW_NULLS};
 enum RobustnessFlag {ROBUST_STRING_TRAVERSAL, FAST_STRING_TRAVERSAL};
 
 
 class StringHasher {
  public:
-  inline StringHasher(int length);
+  explicit inline StringHasher(int length);
 
   // Returns true if the hash of this string can be computed without
   // looking at the contents.
   inline bool has_trivial_hash();
 
   // Add a character to the hash and update the array index calculation.
   inline void AddCharacter(uc32 c);
 
   // Adds a character to the hash but does not update the array index
   // calculation.  This can only be called when it has been verified
@@ skipping 726 matching lines @@
 //
 // StringInputBuffer is able to traverse any string regardless of how
 // deeply nested a sequence of ConsStrings it is made of.  However,
 // performance will be better if deep strings are flattened before they
 // are traversed.  Since flattening requires memory allocation this is
 // not always desirable, however (esp. in debugging situations).
 class StringInputBuffer: public unibrow::InputBuffer<String, String*, 1024> {
  public:
   virtual void Seek(unsigned pos);
   inline StringInputBuffer(): unibrow::InputBuffer<String, String*, 1024>() {}
-  inline StringInputBuffer(String* backing):
+  explicit inline StringInputBuffer(String* backing):
       unibrow::InputBuffer<String, String*, 1024>(backing) {}
 };
 
 
 class SafeStringInputBuffer
   : public unibrow::InputBuffer<String, String**, 256> {
  public:
   virtual void Seek(unsigned pos);
   inline SafeStringInputBuffer()
       : unibrow::InputBuffer<String, String**, 256>() {}
-  inline SafeStringInputBuffer(String** backing)
+  explicit inline SafeStringInputBuffer(String** backing)
       : unibrow::InputBuffer<String, String**, 256>(backing) {}
 };
 
 
 template <typename T>
 class VectorIterator {
  public:
   VectorIterator(T* d, int l) : data_(Vector<const T>(d, l)), index_(0) { }
   explicit VectorIterator(Vector<const T> data) : data_(data), index_(0) { }
   T GetNext() { return data_[index_++]; }
@@ skipping 723 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_