Bug 732321 - Document mfbt style, rather than relying on reviewers to consistently remember and enforce every little bit of it. r=cjones, DONTBUILD because this is adding docs but touching no code
authorJeff Walden <jwalden@mit.edu>
Thu, 01 Mar 2012 20:47:30 -0800
changeset 91748 c49e75123d62dfa9d835256da8b3a72c521660de
parent 91747 dc073cdc3e280c15c13cdfc50f6e36ad84ed84b0
child 91749 62eecc2b684d1188416c6670377b383c1231b1e0
push id136
push userlsblakk@mozilla.com
push dateFri, 01 Jun 2012 02:39:32 +0000
treeherdermozilla-release@7ebf7352c959 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerscjones, DONTBUILD
bugs732321
milestone13.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 732321 - Document mfbt style, rather than relying on reviewers to consistently remember and enforce every little bit of it. r=cjones, DONTBUILD because this is adding docs but touching no code
mfbt/STYLE
new file mode 100644
--- /dev/null
+++ b/mfbt/STYLE
@@ -0,0 +1,273 @@
+= mfbt style rules =
+
+== Line length ==
+
+The line limit is 80 characters, except that excessively long blocks of preprocessor directives may exceed this if it makes the code more readable (e.g. MOZ_STATIC_ASSERT in Assertions.h.), and unbreakable text in comments (e.g. URLs) may exceed this as well.  Wrap expressions after binary operators.
+
+== Capitalization ==
+
+Standalone functions, classes, structs, and template parameters are named InterCaps-style.  Member functions and fields in classes and structs are named camelCaps-style.
+
+== Indentation ==
+
+Indentation is two spaces, never tabs.
+
+  if (x == 2)
+    return 17;
+
+== Whitespace ==
+
+Surround binary operators with a single space on either side.
+
+  if (x == 2)
+    return 17;
+
+When describing pointer types, the * shall be adjacent to the type name.  (Same goes for references -- & goes by the type name.)
+
+  int
+  Foo(int* p)
+  {
+    typedef void* VoidPtr;
+    int& i = *p;
+  }
+
+A corollary: don't mix declaration types by declaring a T and a T* (or a T**, &c.) in the same declaration.
+
+  T* foo, bar; // BAD
+
+== Bracing ==
+
+Don't brace single statements.
+
+  if (y == 7)
+    return 3;
+  for (size_t i = 0; i < 5; i++)
+    frob(i);
+
+But do brace them if the statement (or condition(s) or any additional consequents, if the braces would be associated with an if statement) occupies multiple lines.
+
+  if (cond1 ||
+      cond2)
+  {
+    action();
+  }
+  if (cond1) {
+    consequent();
+  } else {
+    alternative(arg1,
+                arg2);
+  }
+  if (cond1 || cond2) {
+    callMethod(arg1,
+               arg2);
+  }
+  for (size_t j = 0;
+       j < 17;
+       j++)
+  {
+    action();
+  }
+
+Braces in control flow go at the end of the line except when associated with an |if| or loop-head where the condition covers multiple lines
+
+== Classes and structs ==
+
+Inside class and structure definitions, public/private consume one level of indentation.
+
+  class Baz
+  {
+    public:
+      Baz() { }
+  };
+
+The absence of public/private in structs in which all members are public still consumes a level.
+
+  struct Foo
+  {
+      int field;
+  };
+
+Braces delimiting a class or struct go on their own lines.
+
+Member initialization in constructors should be formatted as follows:
+
+  class Fnord
+  {
+      size_t s1, s2, s3, s4, s5;
+
+    public:
+      Fnord(size_t s) : s1(s), s2(s), s3(s), s4(s), s5(s) { }
+      Fnord()
+        : s1(0), /* member initialization can be compressed if desired */
+          s2(0),
+          s3(0),
+          s4(0),
+          s5(0)
+      {
+        ...
+      }
+  };
+
+Fields should go first in the class so that the basic structure is all in one place, consistently.
+
+Use the inline keyword to annotate functions defined inline in a header.  (If the function is defined inline in the class, don't bother adding it redundantly.)
+
+Explicitly delete (using Attributes.h's MOZ_DELETE) the copy constructor and assignment operator from classes not intended to be copied or assigned to avoid mistakes.
+
+  class Funky
+  {
+    public:
+      Funky() { }
+
+    private:
+      Funky(const Funky& other) MOZ_DELETE;
+      void operator=(const Funky& other) MOZ_DELETE;
+  };
+
+Include a blank line between sections of structs and classes with different access control.
+
+The "get" prefix is used when a method is fallible.  If it's infallible, don't use it.
+
+  class String
+  {
+    public:
+      size_t length() const; // not getLength()
+  };
+
+== Templates ==
+
+Capitalize template parameter names to distinguish them from fields.
+
+  template<size_t KeySize, typename T>
+  class BloomFilter
+  {
+  };
+
+Use single-letter names if it makes sense (T for an arbitrary type, K for key type, V for value type, &c.).  Otherwise use InterCaps-style names.
+
+When declaring or defining a function, template<...> goes on one line, the return type and other specifiers go on another line, and the function name and argument list go on a third line.
+
+  template<typename T>
+  inline bool
+  Vector::add(T t)
+  {
+  }
+
+== Namespaces ==
+
+All C++ code shall be in the mozilla namespace, except that functionality only used to implement external-facing API should be in the mozilla::detail namespace, indicating that it should not be directly used.
+
+Namespace opening braces go on the same line as the namespace declaration.  Namespace closing braces shall be commented.  Namespace contents are not indented.
+
+  namespace mozilla {
+  ...
+  } // namespace mozilla
+
+Don't use |using| in a header unless it's confined to a class or method.  Implementation files for out-of-line functionality may use |using|.
+
+== #includes ==
+
+Headers that include mfbt headers use a fully-qualified include path, even if full qualification is not strictly necessary.
+
+  #include "mozilla/Assertions.h"
+
+mfbt headers should be included first, alphabetically.  Standard includes should follow, separated from mfbt includes by a blank line.
+
+  #include "mozilla/Assertions.h"
+  #include "mozilla/Attributes.h"
+  
+  #include <string.h>
+
+If a header dependency is limited simply to the existence of a class, forward-declare it rather than #include that header.
+
+  namespace mozilla {
+  
+  class BloomFilter;
+  extern bool
+  Test(BloomFilter* bf);
+  
+  } // namespace mozilla
+
+== Preprocessor ==
+
+Include guards should be named by determining the fully-qualified include path, then substituting _ for / and . in it, and finally appending a trailing _.  For example, "mozilla/Assertions.h" becomes mozilla_Assertions_h_.
+
+Nested preprocessor directives indent the directive name (but not the #) by two spaces.
+
+  #ifdef __clang__
+  #  define FOO ...
+  #else
+  #  define FOO ...
+  #endif
+
+Comments within nested preprocessor directives align with directive names at that nesting depth.
+
+  #if defined(__GNUC__)
+     /* gcc supports C++11 override syntax. */
+  #  define MOZ_OVERRIDE override
+  #else
+  #  define MOZ_OVERRIDE /* unsupported */
+  #endif
+
+Feature-testing macros may be defined to nothing.  Macros intended to be textually expanded should be defined to a comment indicating non-support, as above or as appropriate to the situation.
+
+No particular preference is expressed between testing for a macro being defined using defined(...) and using #ifdef.
+
+When defining a macro with different expansions for different compilers, the top level of distinction should be the compiler, and the next nested level should be the compiler version.  Clang seems likely to be around for awhile, so to reduce confusion test for it separately from gcc even when it's not strictly necessary.
+
+  #if defined(__clang__)
+  #elif defined(__GNUC__)
+  #  if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+  #  else
+  #  endif
+  #elif defined(_MSC_VER)
+  #endif
+
+But don't distinguish clang's feature support using version checks: use the __has_feature() and __has_extension() macros instead, because vendors may customize clang's version numbers.
+
+Prefer inline functions to macros whenever possible.
+
+== Comments ==
+
+Header files shall have a short descriptive comment underneath license boilerplate indicating what functionality the file implements, to be picked up by MXR and displayed in directory listings.  (But see bug 717196, which currently prevents MXR from doing this if the MPL2 boilerplate is used.)
+
+  Assertions.h:
+  ...license boilerplate...
+  
+  /* Implementations of runtime and static assertion macros for C and C++. */
+
+Classes intended for public use shall have interface comments explaining their functionality from the user's perspective.  These comments shall include examples of how the relevant functionality might be used.  These interface comments use /** */ doxygen/Javadoc-style comments.
+
+  /**
+   * The Frobber class simplifies the process of frobbing.
+   */
+  class Frobber
+  {
+  };
+
+Comments describing implementation details (tradeoffs considered, assumptions made, mathematical background, &c.) occur separately from interface comments so that users need not consider them.  They should go inside the class definition or inside the appropriate method, depending on the specificity of the comment.
+
+Headers which are intended to be C-compatible shall use only /**/-style comments.  (Code examples nested inside documentation comments may use //-style comments.)  Headers which are C++-compatible may also use //-style comments.
+
+Non-interface comments that are /**/-style shall not also be doxygen-style.
+
+Use Python-style ** to denote exponentiation inside comments, not ^ (which can be confused with C-style bitwise xor).  If you're writing sufficiently complex math, feel free to descend into LaTeX math mode ;-) inside implementation comments if you need to.  (But keep it out of interface comments, because most people probably haven't seen LaTeX.)
+
+== Miscellaneous ==
+
+Enclose C-compatible code in |extern "C"| blocks, and #ifdef __cplusplus the block start/end as needed.  The contents of these blocks should not be indented.
+
+Add new functionality to new headers unless an existing header makes sense.  Err on the side of more headers rather than fewer, as this helps to minimize dependencies.  Don't add anything to Util.h, which will be split into multiple headers at some point (bug 713082).
+
+Don't use bool for argument types unless the method is a "set" or "enable"-style method where the method name and bool value together indicate the sense of its effect.  Use well-named enums in all other places, so that the semantics of the argument are clear at a glance and do not require knowing how the method interprets that argument.
+
+  void
+  setVisible(bool visible); // true clearly means visible, false clearly not
+  enum Enumerability {
+    Enumerable,
+    NonEnumerable
+  };
+  bool
+  DefineProperty(JSObject* obj, const char* name, Value v, Enumerability e);
+
+Use NULL for the null pointer constant.