Add styles for a history timeline, needed by an upcoming blog post.
[WebKit-https.git] / Websites / webkit.org / code-style.md
1 ### Indentation
2
3 [](#indentation-no-tabs) Use spaces, not tabs. Tabs should only appear in files that require them for semantic meaning, like Makefiles.
4
5 [](#indentation-4-spaces) The indent size is 4 spaces.
6
7 ###### Right:
8
9 ```cpp
10 int main()
11 {
12     return 0;
13 }
14 ```
15
16 ###### Wrong:
17
18 ```cpp
19 int main() 
20 {
21         return 0;
22 }
23 ```
24
25 [](#indentation-namespace) The contents of an outermost `namespace` block (and any nested namespaces with the same scope) should not be indented. The contents of other nested namespaces should be indented.
26
27 ###### Right:
28
29 ```cpp
30 // Document.h
31 namespace WebCore {
32
33 class Document {
34     Document();
35     ...
36 };
37
38 namespace NestedNamespace {
39     ...
40 }
41
42 } // namespace WebCore
43
44 // Document.cpp
45 namespace WebCore {
46
47 Document::Document()
48 {
49     ...
50 }
51
52 } // namespace WebCore
53 ```
54
55 ###### Wrong:
56
57 ```cpp
58 // Document.h
59 namespace WebCore {
60
61     class Document {
62         Document();
63         ...
64     };
65
66     namespace NestedNamespace {
67     ...
68     }
69
70 } // namespace WebCore
71
72 // Document.cpp
73 namespace WebCore {
74
75     Document::Document()
76     {
77         ...
78     }
79
80 } // namespace WebCore
81 ```
82
83 [](#indentation-case-label) A case label should line up with its switch statement. The case statement is indented.
84
85 ###### Right:
86
87 ```cpp
88 switch (condition) {
89 case fooCondition:
90 case barCondition:
91     i++;
92     break;
93 default:
94     i--;
95 }
96 ```
97
98 ###### Wrong:
99
100 ```cpp
101 switch (condition) {
102     case fooCondition:
103     case barCondition:
104         i++;
105         break;
106     default:
107         i--;
108 }
109 ```
110
111 [](#indentation-wrap-bool-op) Boolean expressions at the same nesting level that span multiple lines should have their operators on the left side of the line instead of the right side.
112
113 ###### Right:
114
115 ```cpp
116 return attribute.name() == srcAttr
117         || attribute.name() == lowsrcAttr
118         || (attribute.name() == usemapAttr && attribute.value().string()[0] != '#');
119 ```
120
121
122 ###### Wrong:
123
124 ```cpp
125 return attribute.name() == srcAttr ||
126         attribute.name() == lowsrcAttr ||
127         (attribute.name() == usemapAttr && attr->value().string()[0] != '#');
128 ```
129
130
131 ### Spacing
132
133 [](#spacing-unary-op) Do not place spaces around unary operators.
134
135 ###### Right:
136
137 ```cpp
138 i++;
139 ```
140
141
142 ###### Wrong:
143
144 ```cpp
145 i ++;
146 ```
147
148 [](#spacing-binary-ternary-op) **Do** place spaces around binary and ternary operators.
149
150 ###### Right:
151
152 ```cpp
153 y = m * x + b;
154 f(a, b);
155 c = a | b;
156 return condition ? 1 : 0;
157 ```
158
159 ###### Wrong:
160
161 ```cpp
162 y=m*x+b;
163 f(a,b);
164 c = a|b;
165 return condition ? 1:0;
166 ```
167
168 [](#spacing-for-colon) Place spaces around the colon in a range-based for loop.
169
170 ###### Right:
171
172 ```cpp
173 Vector<PluginModuleInfo> plugins;
174 for (auto& plugin : plugins)
175     registerPlugin(plugin);
176 ```
177
178 ###### Wrong:
179
180 ```cpp
181 Vector<PluginModuleInfo> plugins;
182 for (auto& plugin: plugins)
183     registerPlugin(plugin);
184 ```
185
186 [](#spacing-comma-semicolon) Do not place spaces before comma and semicolon.
187
188 ###### Right:
189
190 ```cpp
191 for (int i = 0; i < 10; ++i)
192     doSomething();
193
194 f(a, b);
195 ```
196
197 ###### Wrong:
198
199 ```cpp
200 for (int i = 0 ; i < 10 ; ++i)
201     doSomething();
202
203 f(a , b) ;
204 ```
205
206 [](#spacing-control-paren) Place spaces between control statements and their parentheses.
207
208 ###### Right:
209
210 ```cpp
211 if (condition)
212     doIt();
213 ```
214
215 ###### Wrong:
216
217 ```cpp
218 if(condition)
219     doIt();
220 ```
221
222 [](#spacing-function-paren) Do not place spaces between a function and its parentheses, or between a parenthesis and its content.
223
224 ###### Right:
225
226 ```cpp
227 f(a, b);
228 ```
229
230 ###### Wrong:
231
232 ```cpp
233 f (a, b);
234 f( a, b );
235 ```
236
237 ### Line breaking
238
239 [](#linebreaking-multiple-statements) Each statement should get its own line.
240
241 ###### Right:
242
243 ```cpp
244 x++;
245 y++;
246 if (condition)
247     doIt();
248 ```
249
250 ###### Wrong:
251
252 ```cpp
253 x++; y++;
254 if (condition) doIt();
255 ```
256
257 [](#linebreaking-else-braces) An `else` statement should go on the same line as a preceding close brace if one is present, else it should line up with the `if` statement.
258
259 ###### Right:
260
261 ```cpp
262 if (condition) {
263     ...
264 } else {
265     ...
266 }
267
268 if (condition)
269     doSomething();
270 else
271     doSomethingElse();
272
273 if (condition)
274     doSomething();
275 else {
276     ...
277 }
278 ```
279
280 ###### Wrong:
281
282 ```cpp
283 if (condition) {
284     ...
285 }
286 else {
287     ...
288 }
289
290 if (condition) doSomething(); else doSomethingElse();
291
292 if (condition) doSomething(); else {
293     ...
294 }
295 ```
296
297 [](#linebreaking-else-if) An `else if` statement should be written as an `if` statement when the prior `if` concludes with a `return` statement.
298
299 ###### Right:
300
301 ```cpp
302 if (condition) {
303     ...
304     return someValue;
305 }
306 if (condition) {
307     ...
308 }
309 ```
310
311 ###### Wrong:
312
313 ```cpp
314 if (condition) {
315     ...
316     return someValue;
317 } else if (condition) {
318     ...
319 }
320 ```
321
322 ### Braces
323
324 [](#braces-function) Function definitions: place each brace on its own line.
325
326 ###### Right:
327
328 ```cpp
329 int main()
330 {
331     ...
332 }
333 ```
334
335 ###### Wrong:
336
337 ```cpp
338 int main() {
339     ...
340 }
341 ```
342
343 [](#braces-blocks) Other braces: place the open brace on the line preceding the code block; place the close brace on its own line.
344
345 ###### Right:
346
347 ```cpp
348 class MyClass {
349     ...
350 };
351
352 namespace WebCore {
353     ...
354 }
355
356 for (int i = 0; i < 10; ++i) {
357     ...
358 }
359 ```
360
361 ###### Wrong:
362
363 ```cpp
364 class MyClass 
365 {
366     ...
367 };
368 ```
369
370 [](#braces-one-line) One-line control clauses should not use braces unless comments are included or a single statement spans multiple lines.
371
372 ###### Right:
373
374 ```cpp
375 if (condition)
376     doIt();
377
378 if (condition) {
379     // Some comment
380     doIt();
381 }
382
383 if (condition) {
384     myFunction(reallyLongParam1, reallyLongParam2, ...
385         reallyLongParam5);
386 }
387 ```
388
389 ###### Wrong:
390
391 ```cpp
392 if (condition) {
393     doIt();
394 }
395
396 if (condition)
397     // Some comment
398     doIt();
399
400 if (condition)
401     myFunction(reallyLongParam1, reallyLongParam2, ...
402         reallyLongParam5);
403 ```
404
405 [](#braces-empty-block) Control clauses without a body should use empty braces:
406
407 ###### Right:
408
409 ```cpp
410 for ( ; current; current = current->next) { }
411 ```
412
413 ###### Wrong:
414
415 ```cpp
416 for ( ; current; current = current->next);
417 ```
418
419 ### Null, false and zero
420
421 [](#zero-null) In C++, the null pointer value should be written as `nullptr`. In C, it should be written as `NULL`. In Objective-C and Objective-C++, follow the guideline for C or C++, respectively, but use `nil` to represent a null Objective-C object.
422
423 [](#zero-bool) C++ and C `bool` values should be written as `true` and `false`. Objective-C `BOOL` values should be written as `YES` and `NO`.
424
425 [](#zero-comparison) Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons.
426
427 ###### Right:
428
429 ```cpp
430 if (condition)
431     doIt();
432
433 if (!ptr)
434     return;
435
436 if (!count)
437     return;
438 ```
439
440 ###### Wrong:
441
442 ```cpp
443 if (condition == true)
444     doIt();
445
446 if (ptr == NULL)
447     return;
448
449 if (count == 0)
450     return;
451 ```
452
453 [](#zero-objc-variables) In Objective-C, instance variables are initialized to zero automatically. Don't add explicit initializations to nil or NO in an init method.
454
455 ### Floating point literals
456
457 [](#float-suffixes) Unless required in order to force floating point math, do not append `.0`, `.f` and `.0f` to floating point literals.
458
459 ###### Right:
460
461 ```cpp
462 const double duration = 60;
463
464 void setDiameter(float diameter)
465 {
466     radius = diameter / 2;
467 }
468
469 setDiameter(10);
470
471 const int framesPerSecond = 12;
472 double frameDuration = 1.0 / framesPerSecond;
473 ```
474
475 ###### Wrong:
476
477 ```cpp
478 const double duration = 60.0;
479
480 void setDiameter(float diameter)
481 {
482     radius = diameter / 2.f;
483 }
484
485 setDiameter(10.f);
486
487 const int framesPerSecond = 12;
488 double frameDuration = 1 / framesPerSecond; // integer division
489 ```
490
491 ### Names
492
493 [](#names-basic) Use CamelCase. Capitalize the first letter, including all letters in an acronym, in a class, struct, protocol, or namespace name. Lower-case the first letter, including all letters in an acronym, in a variable or function name.
494
495 ###### Right:
496
497 ```cpp
498 struct Data;
499 size_t bufferSize;
500 class HTMLDocument;
501 String mimeType();
502 ```
503
504 ###### Wrong:
505
506 ```cpp
507 struct data;
508 size_t buffer_size;
509 class HtmlDocument;
510 String MIMEType();
511 ```
512
513 [](#names-full-words) Use full words, except in the rare case where an abbreviation would be more canonical and easier to understand.
514
515 ###### Right:
516
517 ```cpp
518 size_t characterSize;
519 size_t length;
520 short tabIndex; // more canonical
521 ```
522
523 ###### Wrong:
524
525 ```cpp
526 size_t charSize;
527 size_t len;
528 short tabulationIndex; // bizarre
529 ```
530
531 [](#names-data-members) Data members in C++ classes should be private. Static data members should be prefixed by "s_". Other data members should be prefixed by "m_".
532
533 ###### Right:
534
535 ```cpp
536 class String {
537 public:
538     ...
539
540 private:
541     short m_length;
542 };
543 ```
544
545 ###### Wrong:
546
547 ```cpp
548 class String {
549 public:
550     ...
551
552     short length;
553 };
554 ```
555
556 [](#names-objc-instance-variables) Prefix Objective-C instance variables with "_".
557
558 ###### Right:
559
560 ```cpp
561 @class String
562     ...
563     short _length;
564 @end
565 ```
566
567 ###### Wrong:
568
569 ```cpp
570 @class String
571     ...
572     short length;
573 @end
574 ```
575
576 [](#names-bool) Precede boolean values with words like "is" and "did".
577
578 ###### Right:
579
580 ```cpp
581 bool isValid;
582 bool didSendData;
583 ```
584
585 ###### Wrong:
586
587 ```cpp
588 bool valid;
589 bool sentData;
590 ```
591
592 [](#names-setter-getter) Precede setters with the word "set". Use bare words for getters. Setter and getter names should match the names of the variables being set/gotten.
593
594 ###### Right:
595
596 ```cpp
597 void setCount(size_t); // sets m_count
598 size_t count(); // returns m_count
599 ```
600
601 ###### Wrong:
602
603 ```cpp
604 void setCount(size_t); // sets m_theCount
605 size_t getCount();
606 ```
607
608 [](#names-out-argument) Precede getters that return values through out arguments with the word "get".
609
610 ###### Right:
611
612 ```cpp
613 void getInlineBoxAndOffset(InlineBox*&, int& caretOffset) const;
614 ```
615
616 ###### Wrong:
617
618 ```cpp
619 void inlineBoxAndOffset(InlineBox*&, int& caretOffset) const;
620 ```
621
622 [](#names-verb) Use descriptive verbs in function names.
623
624 ###### Right:
625
626 ```cpp
627 bool convertToASCII(short*, size_t);
628 ```
629
630 ###### Wrong:
631
632 ```cpp
633 bool toASCII(short*, size_t);
634 ```
635
636 [](#names-variable-name-in-function-decl) Leave meaningless variable names out of function declarations. A good rule of thumb is if the parameter type name contains the parameter name (without trailing numbers or pluralization), then the parameter name isn't needed. Usually, there should be a parameter name for bools, strings, and numerical types.
637
638 ###### Right:
639
640 ```cpp
641 void setCount(size_t);
642
643 void doSomething(ScriptExecutionContext*);
644 ```
645
646 ###### Wrong:
647
648 ```cpp
649 void setCount(size_t count);
650
651 void doSomething(ScriptExecutionContext* context);
652 ```
653
654 [](#names-enum-to-bool) Prefer enums to bools on function parameters if callers are likely to be passing constants, since named constants are easier to read at the call site. An exception to this rule is a setter function, where the name of the function already makes clear what the boolean is.
655
656 ###### Right:
657
658 ```cpp
659 doSomething(something, AllowFooBar);
660 paintTextWithShadows(context, ..., textStrokeWidth > 0, isHorizontal());
661 setResizable(false);
662 ```
663
664 ###### Wrong:
665
666 ```cpp
667 doSomething(something, false);
668 setResizable(NotResizable);
669 ```
670
671 [](#names-objc-methods) Objective-C method names should follow the Cocoa naming guidelines — they should read like a phrase and each piece of the selector should start with a lowercase letter and use intercaps.
672
673 [](#names-enum-members) Enum members should use InterCaps with an initial capital letter.
674
675 [](#names-const-to-define) Prefer `const` to `#define`. Prefer inline functions to macros.
676
677 [](#names-define-constants) `#defined` constants should use all uppercase names with words separated by underscores.
678
679 [](#names-define-non-const) Macros that expand to function calls or other non-constant computation: these should be named like functions, and should have parentheses at the end, even if they take no arguments (with the exception of some special macros like ASSERT). Note that usually it is preferable to use an inline function in such cases instead of a macro.
680
681 ###### Right:
682
683 ```cpp
684 #define WBStopButtonTitle() \
685         NSLocalizedString(@"Stop", @"Stop button title")
686 ```
687
688 ###### Wrong:
689
690 ```cpp
691 #define WB_STOP_BUTTON_TITLE \
692         NSLocalizedString(@"Stop", @"Stop button title")
693
694 #define WBStopButtontitle \
695         NSLocalizedString(@"Stop", @"Stop button title")
696 ```
697
698 [](#names-header-guards) `#define`, `#ifdef` "header guards" should be named exactly the same as the file (including case), replacing the `.` with a `_`.
699
700 ###### Right:
701
702 ```cpp
703 // HTMLDocument.h
704 #ifndef HTMLDocument_h
705 #define HTMLDocument_h
706 ```
707
708 ###### Wrong:
709
710 ```cpp
711 // HTMLDocument.h
712 #ifndef _HTML_DOCUMENT_H_
713 #define _HTML_DOCUMENT_H_
714 ```
715
716 ### Other Punctuation
717
718 [](#punctuation-member-init) Constructors for C++ classes should initialize all of their members using C++ initializer syntax. Each member (and superclass) should be indented on a separate line, with the colon or comma preceding the member on that line.
719
720 ###### Right:
721
722 ```cpp
723 MyClass::MyClass(Document* document)
724     : MySuperClass()
725     , m_myMember(0)
726     , m_document(document)
727 {
728 }
729
730 MyOtherClass::MyOtherClass()
731     : MySuperClass()
732 {
733 }
734 ```
735
736 ###### Wrong:
737
738 ```cpp
739 MyClass::MyClass(Document* document) : MySuperClass()
740 {
741     m_myMember = 0;
742     m_document = document;
743 }
744
745 MyOtherClass::MyOtherClass() : MySuperClass() {}
746 ```
747
748 [](#punctuation-vector-index) Prefer index over iterator in Vector iterations for terse, easier-to-read code.
749
750 ###### Right:
751
752 ```cpp
753 for (auto& frameView : frameViews)
754         frameView->updateLayoutAndStyleIfNeededRecursive();
755 ```
756
757
758 #### OK:
759
760 ```cpp
761 unsigned frameViewsCount = frameViews.size();
762 for (unsigned i = 0; i < frameViewsCount; ++i)
763     frameViews[i]->updateLayoutAndStyleIfNeededRecursive();
764 ```
765
766 ###### Wrong:
767
768 ```cpp
769 const Vector<RefPtr<FrameView> >::iterator end = frameViews.end();
770 for (Vector<RefPtr<FrameView> >::iterator it = frameViews.begin(); it != end; ++it)
771     (*it)->updateLayoutAndStyleIfNeededRecursive();
772 ```
773
774 ### Pointers and References
775
776 [](#pointers-non-cpp) **Pointer types in non-C++ code**
777 Pointer types should be written with a space between the type and the `*` (so the `*` is adjacent to the following identifier if any).
778
779 [](#pointers-cpp) **Pointer and reference types in C++ code**
780 Both pointer types and reference types should be written with no space between the type name and the `*` or `&`.
781
782 ###### Right:
783
784 ```cpp
785 Image* SVGStyledElement::doSomething(PaintInfo& paintInfo)
786 {
787     SVGStyledElement* element = static_cast<SVGStyledElement*>(node());
788     const KCDashArray& dashes = dashArray();
789 ```
790
791 ###### Wrong:
792
793 ```cpp
794 Image *SVGStyledElement::doSomething(PaintInfo &paintInfo)
795 {
796     SVGStyledElement *element = static_cast<SVGStyledElement *>(node());
797     const KCDashArray &dashes = dashArray();
798 ```
799
800 [](#pointers-out-argument) An out argument of a function should be passed by reference except rare cases where it is optional in which case it should be passed by pointer.
801
802 ###### Right:
803
804 ```cpp
805 void MyClass::getSomeValue(OutArgumentType& outArgument) const
806 {
807     outArgument = m_value;
808 }
809
810 void MyClass::doSomething(OutArgumentType* outArgument) const
811 {
812     doSomething();
813     if (outArgument)
814         *outArgument = m_value;
815 }
816 ```
817
818 ###### Wrong:
819
820 ```cpp
821 void MyClass::getSomeValue(OutArgumentType* outArgument) const
822 {
823     *outArgument = m_value;
824 }
825 ```
826
827 ### #include Statements
828
829 [](#include-config-h) All implementation files must `#include` `config.h` first. Header files should never include `config.h`.
830
831 ###### Right:
832
833 ```cpp
834 // RenderLayer.h
835 #include "Node.h"
836 #include "RenderObject.h"
837 #include "RenderView.h"
838 ```
839
840 ###### Wrong:
841
842 ```cpp
843 // RenderLayer.h
844 #include "config.h"
845
846 #include "RenderObject.h"
847 #include "RenderView.h"
848 #include "Node.h"
849 ```
850
851 [](#include-primary) All implementation files must `#include` the primary header second, just after `config.h`. So for example, `Node.cpp` should include `Node.h` first, before other files. This guarantees that each header's completeness is tested. This also assures that each header can be compiled without requiring any other header files be included first.
852
853 [](#include-others) Other `#include` statements should be in sorted order (case sensitive, as done by the command-line sort tool or the Xcode sort selection command). Don't bother to organize them in a logical order.
854
855 ###### Right:
856
857 ```cpp
858 // HTMLDivElement.cpp
859 #include "config.h"
860 #include "HTMLDivElement.h"
861
862 #include "Attribute.h"
863 #include "HTMLElement.h"
864 #include "QualifiedName.h"
865 ```
866
867 ###### Wrong:
868
869 ```cpp
870 // HTMLDivElement.cpp
871 #include "HTMLElement.h"
872 #include "HTMLDivElement.h"
873 #include "QualifiedName.h"
874 #include "Attribute.h"
875 ```
876
877 [](#include-system) Includes of system headers must come after includes of other headers.
878
879 ###### Right:
880
881 ```cpp
882 // ConnectionQt.cpp
883 #include "ArgumentEncoder.h"
884 #include "ProcessLauncher.h"
885 #include "WebPageProxyMessageKinds.h"
886 #include "WorkItem.h"
887 #include <QApplication>
888 #include <QLocalServer>
889 #include <QLocalSocket>
890 ```
891
892 ###### Wrong:
893
894 ```cpp
895 // ConnectionQt.cpp
896 #include "ArgumentEncoder.h"
897 #include "ProcessLauncher.h"
898 #include <QApplication>
899 #include <QLocalServer>
900 #include <QLocalSocket>
901 #include "WebPageProxyMessageKinds.h"
902 #include "WorkItem.h"
903 ```
904
905 ### "using" Statements
906
907 [](#using-in-headers) In header files, do not use "using" statements in namespace (or global) scope.
908
909 ###### Right:
910
911 ```cpp
912 // wtf/Vector.h
913
914 namespace WTF {
915
916 class VectorBuffer {
917     using std::min;
918     ...
919 };
920
921 } // namespace WTF
922 ```
923
924 ###### Wrong:
925
926 ```cpp
927 // wtf/Vector.h
928
929 namespace WTF {
930
931 using std::min;
932
933 class VectorBuffer {
934     ...
935 };
936
937 } // namespace WTF
938 ```
939
940 [](#using-wtf) In header files in the WTF sub-library, however, it is acceptable to use "using" declarations at the end of the file to import one or more names in the WTF namespace into the global scope.
941
942 ###### Right:
943
944 ```cpp
945 // wtf/Vector.h
946
947 namespace WTF {
948
949 } // namespace WTF
950
951 using WTF::Vector;
952 ```
953
954 ###### Wrong:
955
956 ```cpp
957 // wtf/Vector.h
958
959 namespace WTF {
960
961 } // namespace WTF
962
963 using namespace WTF;
964 ```
965
966 ###### Wrong:
967
968 ```cpp
969 // runtime/JSObject.h
970
971 namespace WTF {
972
973 } // namespace WTF
974
975 using WTF::PlacementNewAdopt;
976 ```
977
978 [](#using-in-cpp) In C++ implementation files, do not use "using" declarations of any kind to import names in the standard template library. Directly qualify the names at the point they're used instead.
979
980 ###### Right:
981
982 ```cpp
983 // HTMLBaseElement.cpp
984
985 namespace WebCore {
986
987   std::swap(a, b);
988   c = std::numeric_limits<int>::max()
989
990 } // namespace WebCore
991 ```
992
993 ###### Wrong:
994
995 ```cpp
996 // HTMLBaseElement.cpp
997
998 using std::swap;
999
1000 namespace WebCore {
1001
1002   swap(a, b);
1003
1004 } // namespace WebCore
1005 ```
1006
1007 ###### Wrong:
1008
1009 ```cpp
1010 // HTMLBaseElement.cpp
1011
1012 using namespace std;
1013
1014 namespace WebCore {
1015
1016   swap(a, b);
1017
1018 } // namespace WebCore
1019 ```
1020
1021 [](#using-nested-namespaces) In implementation files, if a "using namespace" statement is for a nested namespace whose parent namespace is defined in the file, put the statement inside that namespace definition.
1022
1023 ###### Right:
1024
1025 ```cpp
1026 // HTMLBaseElement.cpp
1027
1028 namespace WebCore {
1029
1030 using namespace HTMLNames;
1031
1032 } // namespace WebCore
1033 ```
1034
1035 ###### Wrong:
1036
1037 ```cpp
1038 // HTMLBaseElement.cpp
1039
1040 using namespace WebCore::HTMLNames;
1041
1042 namespace WebCore {
1043
1044 } // namespace WebCore
1045 ```
1046
1047 [](#using-position) In implementation files, put all other "using" statements at the beginning of the file, before any namespace definitions and after any "include" statements.
1048
1049 ###### Right:
1050
1051 ```cpp
1052 // HTMLSelectElement.cpp
1053
1054 using namespace other;
1055
1056 namespace WebCore {
1057
1058 } // namespace WebCore
1059 ```
1060
1061 ###### Wrong:
1062
1063 ```cpp
1064 // HTMLSelectElement.cpp
1065
1066 namespace WebCore {
1067
1068 using namespace other;
1069
1070 } // namespace WebCore
1071 ```
1072
1073 ### Types
1074
1075 [](#types-unsigned) Omit "int" when using "unsigned" modifier. Do not use "signed" modifier. Use "int" by itself instead.
1076
1077 ###### Right:
1078
1079 ```cpp
1080 unsigned a;
1081 int b;
1082 ```
1083
1084 ###### Wrong:
1085
1086 ```cpp
1087 unsigned int a; // Doesn't omit "int".
1088 signed b; // Uses "signed" instead of "int".
1089 signed int c; // Doesn't omit "signed".
1090 ```
1091
1092 ### Classes
1093
1094 [](#classes-explicit) Use a constructor to do an implicit conversion when the argument is reasonably thought of as a type conversion and the type conversion is fast. Otherwise, use the explicit keyword or a function returning the type. This only applies to single argument constructors.
1095
1096 ###### Right:
1097
1098 ```cpp
1099 class LargeInt {
1100 public:
1101     LargeInt(int);
1102 ...
1103
1104 class Vector {
1105 public:
1106     explicit Vector(int size); // Not a type conversion.
1107     Vector create(Array); // Costly conversion.
1108 ...
1109
1110 ```
1111
1112 ###### Wrong:
1113
1114 ```cpp
1115 class Task {
1116 public:
1117     Task(ScriptExecutionContext&); // Not a type conversion.
1118     explicit Task(); // No arguments.
1119     explicit Task(ScriptExecutionContext&, Other); // More than one argument.
1120 ...
1121 ```
1122
1123 ### Singleton pattern
1124
1125 [](#singleton-static-member) Use a static member function named "singleton()" to access the instance of the singleton.
1126
1127 ###### Right:
1128
1129 ```cpp
1130 class MySingleton {
1131 public:
1132     static MySingleton& singleton();
1133 ...
1134 ```
1135
1136 ###### Wrong:
1137
1138 ```cpp
1139 class MySingleton {
1140 public:
1141     static MySingleton& shared();
1142 ...
1143 ```
1144
1145 ###### Wrong:
1146
1147 ```cpp
1148 class MySingleton {
1149 ...
1150 };
1151
1152 MySingleton& mySingleton(); // free function.
1153 ```
1154
1155 ### Comments
1156
1157 [](#comments-eol) Use only _one_ space before end of line comments and in between sentences in comments.
1158
1159 ###### Right:
1160
1161 ```cpp
1162 f(a, b); // This explains why the function call was done. This is another sentence.
1163 ```
1164
1165 ###### Wrong:
1166
1167 ```cpp
1168 int i;    // This is a comment with several spaces before it, which is a non-conforming style.
1169 double f; // This is another comment.  There are two spaces before this sentence which is a non-conforming style.
1170 ```
1171
1172 [](#comments-sentences) Make comments look like sentences by starting with a capital letter and ending with a period (punctation). One exception may be end of line comments like this `if (x == y) // false for NaN`.
1173
1174 [](#comments-fixme) Use FIXME: (without attribution) to denote items that need to be addressed in the future.
1175
1176 ###### Right:
1177
1178 ```cpp
1179 drawJpg(); // FIXME: Make this code handle jpg in addition to the png support.
1180 ```
1181
1182 ###### Wrong:
1183
1184 ```cpp
1185 drawJpg(); // FIXME(joe): Make this code handle jpg in addition to the png support.
1186 ```
1187
1188 ```cpp
1189 drawJpg(); // TODO: Make this code handle jpg in addition to the png support.
1190 ```