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