[GTK][WPE] Bump libsoup3 version to 2.99.1
[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 [](#spacing-lambda-paren) Do not place spaces between square brackets and parentheses of a lambda function but do place a space before braces.
238
239 ###### Right:
240
241 ```cpp
242 [](int x) { return x; }
243 [this] { return m_member; }
244 ```
245
246 ###### Wrong:
247
248 ```cpp
249 [] (int x) { return x; }
250 [this]{ return m_member; }
251 ```
252
253 [](#spacing-braced-init) When initializing an object, place a space before the leading brace as well as between the braces and their content.
254
255 ###### Right:
256
257 ```cpp
258 Foo foo { bar };
259 ```
260
261 ###### Wrong:
262
263 ```cpp
264 Foo foo{ bar };
265 Foo foo {bar};
266 ```
267
268 [](#spacing-objc-block) In Objective-C, do not place spaces between the start of a block and its arguments, or the start of a block and its opening brace. **Do** place a space between argument lists and the opening brace of the block.
269
270 ###### Right:
271
272 ```cpp
273 block = ^{
274 ...
275 };
276
277 block = ^(int, int) {
278 ...
279 };
280
281 ```
282
283 ###### Wrong:
284
285 ```cpp
286 block = ^ {
287 ...
288 };
289
290 block = ^ (int, int){
291 ...
292 };
293
294 ```
295
296 ### Line breaking
297
298 [](#linebreaking-multiple-statements) Each statement should get its own line.
299
300 ###### Right:
301
302 ```cpp
303 x++;
304 y++;
305 if (condition)
306     doIt();
307 ```
308
309 ###### Wrong:
310
311 ```cpp
312 x++; y++;
313 if (condition) doIt();
314 ```
315
316 [](#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.
317
318 ###### Right:
319
320 ```cpp
321 if (condition) {
322     ...
323 } else {
324     ...
325 }
326
327 if (condition)
328     doSomething();
329 else
330     doSomethingElse();
331
332 if (condition)
333     doSomething();
334 else {
335     ...
336 }
337 ```
338
339 ###### Wrong:
340
341 ```cpp
342 if (condition) {
343     ...
344 }
345 else {
346     ...
347 }
348
349 if (condition) doSomething(); else doSomethingElse();
350
351 if (condition) doSomething(); else {
352     ...
353 }
354 ```
355
356 [](#linebreaking-else-if) An `else if` statement should be written as an `if` statement when the prior `if` concludes with a `return` statement.
357
358 ###### Right:
359
360 ```cpp
361 if (condition) {
362     ...
363     return someValue;
364 }
365 if (condition) {
366     ...
367 }
368 ```
369
370 ###### Wrong:
371
372 ```cpp
373 if (condition) {
374     ...
375     return someValue;
376 } else if (condition) {
377     ...
378 }
379 ```
380
381 ### Braces
382
383 [](#braces-function) Function definitions: place each brace on its own line.
384
385 ###### Right:
386
387 ```cpp
388 int main()
389 {
390     ...
391 }
392 ```
393
394 ###### Wrong:
395
396 ```cpp
397 int main() {
398     ...
399 }
400 ```
401
402 [](#braces-blocks) Other braces: place the open brace on the line preceding the code block; place the close brace on its own line.
403
404 ###### Right:
405
406 ```cpp
407 class MyClass {
408     ...
409 };
410
411 namespace WebCore {
412     ...
413 }
414
415 for (int i = 0; i < 10; ++i) {
416     ...
417 }
418 ```
419
420 ###### Wrong:
421
422 ```cpp
423 class MyClass 
424 {
425     ...
426 };
427 ```
428
429 [](#braces-one-line) One-line control clauses should not use braces unless comments are included or a single statement spans multiple lines.
430
431 ###### Right:
432
433 ```cpp
434 if (condition)
435     doIt();
436
437 if (condition) {
438     // Some comment
439     doIt();
440 }
441
442 if (condition) {
443     myFunction(reallyLongParam1, reallyLongParam2, ...
444         reallyLongParam5);
445 }
446 ```
447
448 ###### Wrong:
449
450 ```cpp
451 if (condition) {
452     doIt();
453 }
454
455 if (condition)
456     // Some comment
457     doIt();
458
459 if (condition)
460     myFunction(reallyLongParam1, reallyLongParam2, ...
461         reallyLongParam5);
462 ```
463
464 [](#braces-empty-block) Control clauses without a body should use empty braces:
465
466 ###### Right:
467
468 ```cpp
469 for ( ; current; current = current->next) { }
470 ```
471
472 ###### Wrong:
473
474 ```cpp
475 for ( ; current; current = current->next);
476 ```
477
478 ### Null, false and zero
479
480 [](#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.
481
482 [](#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`.
483
484 [](#zero-comparison) Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons.
485
486 ###### Right:
487
488 ```cpp
489 if (condition)
490     doIt();
491
492 if (!ptr)
493     return;
494
495 if (!count)
496     return;
497 ```
498
499 ###### Wrong:
500
501 ```cpp
502 if (condition == true)
503     doIt();
504
505 if (ptr == NULL)
506     return;
507
508 if (count == 0)
509     return;
510 ```
511
512 [](#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.
513
514 ### Floating point literals
515
516 [](#float-suffixes) Unless required in order to force floating point math, do not append `.0`, `.f` and `.0f` to floating point literals.
517
518 ###### Right:
519
520 ```cpp
521 const double duration = 60;
522
523 void setDiameter(float diameter)
524 {
525     radius = diameter / 2;
526 }
527
528 setDiameter(10);
529
530 const int framesPerSecond = 12;
531 double frameDuration = 1.0 / framesPerSecond;
532 ```
533
534 ###### Wrong:
535
536 ```cpp
537 const double duration = 60.0;
538
539 void setDiameter(float diameter)
540 {
541     radius = diameter / 2.f;
542 }
543
544 setDiameter(10.f);
545
546 const int framesPerSecond = 12;
547 double frameDuration = 1 / framesPerSecond; // integer division
548 ```
549
550 ### Names
551
552 [](#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.
553
554 ###### Right:
555
556 ```cpp
557 struct Data;
558 size_t bufferSize;
559 class HTMLDocument;
560 String mimeType();
561 ```
562
563 ###### Wrong:
564
565 ```cpp
566 struct data;
567 size_t buffer_size;
568 class HtmlDocument;
569 String MIMEType();
570 ```
571
572 [](#names-full-words) Use full words, except in the rare case where an abbreviation would be more canonical and easier to understand.
573
574 ###### Right:
575
576 ```cpp
577 size_t characterSize;
578 size_t length;
579 short tabIndex; // more canonical
580 ```
581
582 ###### Wrong:
583
584 ```cpp
585 size_t charSize;
586 size_t len;
587 short tabulationIndex; // bizarre
588 ```
589
590 [](#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_".
591
592 ###### Right:
593
594 ```cpp
595 class String {
596 public:
597     ...
598
599 private:
600     short m_length;
601 };
602 ```
603
604 ###### Wrong:
605
606 ```cpp
607 class String {
608 public:
609     ...
610
611     short length;
612 };
613 ```
614
615 [](#names-objc-instance-variables) Prefix Objective-C instance variables with "_".
616
617 ###### Right:
618
619 ```cpp
620 @class String
621     ...
622     short _length;
623 @end
624 ```
625
626 ###### Wrong:
627
628 ```cpp
629 @class String
630     ...
631     short length;
632 @end
633 ```
634
635 [](#names-bool) Precede boolean values with words like "is" and "did".
636
637 ###### Right:
638
639 ```cpp
640 bool isValid;
641 bool didSendData;
642 ```
643
644 ###### Wrong:
645
646 ```cpp
647 bool valid;
648 bool sentData;
649 ```
650
651 [](#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.
652
653 ###### Right:
654
655 ```cpp
656 void setCount(size_t); // sets m_count
657 size_t count(); // returns m_count
658 ```
659
660 ###### Wrong:
661
662 ```cpp
663 void setCount(size_t); // sets m_theCount
664 size_t getCount();
665 ```
666
667 [](#names-out-argument) Precede getters that return values through out arguments with the word "get".
668
669 ###### Right:
670
671 ```cpp
672 void getInlineBoxAndOffset(InlineBox*&, int& caretOffset) const;
673 ```
674
675 ###### Wrong:
676
677 ```cpp
678 void inlineBoxAndOffset(InlineBox*&, int& caretOffset) const;
679 ```
680
681 [](#names-verb) Use descriptive verbs in function names.
682
683 ###### Right:
684
685 ```cpp
686 bool convertToASCII(short*, size_t);
687 ```
688
689 ###### Wrong:
690
691 ```cpp
692 bool toASCII(short*, size_t);
693 ```
694
695 [](#names-if-exists) The getter function for a member variable should not have any suffix or prefix indicating the function can optionally create or initialize the member variable. Suffix the getter function which does not automatically create the object with `IfExists` if there is a variant which does.
696
697 ###### Right:
698
699 ```cpp
700 StyleResolver* styleResolverIfExists();
701 StyleResolver& styleResolver();
702 ```
703
704 ###### Wrong:
705
706 ```cpp
707 StyleResolver* styleResolver();
708 StyleResolver& ensureStyleResolver();
709 ```
710
711 ###### Right:
712
713 ```cpp
714 Frame* frame();
715 ```
716
717 ###### Wrong:
718
719 ```cpp
720 Frame* frameIfExists();
721 ```
722
723 [](#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.
724
725 ###### Right:
726
727 ```cpp
728 void setCount(size_t);
729
730 void doSomething(ScriptExecutionContext*);
731 ```
732
733 ###### Wrong:
734
735 ```cpp
736 void setCount(size_t count);
737
738 void doSomething(ScriptExecutionContext* context);
739 ```
740
741 [](#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.
742
743 ###### Right:
744
745 ```cpp
746 doSomething(something, AllowFooBar);
747 paintTextWithShadows(context, ..., textStrokeWidth > 0, isHorizontal());
748 setResizable(false);
749 ```
750
751 ###### Wrong:
752
753 ```cpp
754 doSomething(something, false);
755 setResizable(NotResizable);
756 ```
757
758 [](#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.
759
760 [](#names-enum-members) Enum members should use InterCaps with an initial capital letter.
761
762 [](#names-const-to-define) Prefer `const` to `#define`. Prefer inline functions to macros.
763
764 [](#names-define-constants) `#defined` constants should use all uppercase names with words separated by underscores.
765
766 [](#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.
767
768 ###### Right:
769
770 ```cpp
771 #define WBStopButtonTitle() \
772         NSLocalizedString(@"Stop", @"Stop button title")
773 ```
774
775 ###### Wrong:
776
777 ```cpp
778 #define WB_STOP_BUTTON_TITLE \
779         NSLocalizedString(@"Stop", @"Stop button title")
780
781 #define WBStopButtontitle \
782         NSLocalizedString(@"Stop", @"Stop button title")
783 ```
784
785 [](#header-guards) Use `#pragma once` instead of `#define` and `#ifdef` for header guards.
786
787 ###### Right:
788
789 ```cpp
790 // HTMLDocument.h
791 #pragma once
792 ```
793
794 ###### Wrong:
795
796 ```cpp
797 // HTMLDocument.h
798 #ifndef HTMLDocument_h
799 #define HTMLDocument_h
800 ```
801
802 [](#names-protectors-this) Ref and RefPtr objects meant to protect `this` from deletion should be named "protectedThis".
803
804 ###### Right:
805
806 ```cpp
807 RefPtr<Node> protectedThis(this);
808 Ref<Element> protectedThis(*this);
809 RefPtr<Widget> protectedThis = this;
810 ```
811
812 ###### Wrong:
813
814 ```cpp
815 RefPtr<Node> protector(this);
816 Ref<Node> protector = *this;
817 RefPtr<Widget> self(this);
818 Ref<Element> elementRef(*this);
819 ```
820
821 [](#names-protectors) Ref and RefPtr objects meant to protect variables other than `this` from deletion should be named either "protector", or "protected" combined with the capitalized form of the variable name.
822
823 ###### Right:
824
825 ```cpp
826 RefPtr<Element> protector(&element);
827 RefPtr<Element> protector = &element;
828 RefPtr<Node> protectedNode(node);
829 RefPtr<Widget> protectedMainWidget(m_mainWidget);
830 RefPtr<Loader> protectedFontLoader = m_fontLoader;
831 ```
832
833 ###### Wrong:
834
835 ```cpp
836 RefPtr<Node> nodeRef(&rootNode);
837 Ref<Element> protect(*element);
838 RefPtr<Node> protectorNode(node);
839 RefPtr<Widget> protected = widget;
840 ```
841
842 ### Other Punctuation
843
844 [](#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.
845
846 ###### Right:
847
848 ```cpp
849 MyClass::MyClass(Document* document)
850     : MySuperClass()
851     , m_myMember(0)
852     , m_document(document)
853 {
854 }
855
856 MyOtherClass::MyOtherClass()
857     : MySuperClass()
858 {
859 }
860 ```
861
862 ###### Wrong:
863
864 ```cpp
865 MyClass::MyClass(Document* document) : MySuperClass()
866 {
867     m_myMember = 0;
868     m_document = document;
869 }
870
871 MyOtherClass::MyOtherClass() : MySuperClass() {}
872 ```
873
874 [](#punctuation-vector-index) Prefer index over iterator in Vector iterations for terse, easier-to-read code.
875
876 ###### Right:
877
878 ```cpp
879 for (auto& frameView : frameViews)
880     frameView->updateLayoutAndStyleIfNeededRecursive();
881 ```
882
883
884 #### OK:
885
886 ```cpp
887 unsigned frameViewsCount = frameViews.size();
888 for (unsigned i = 0; i < frameViewsCount; ++i)
889     frameViews[i]->updateLayoutAndStyleIfNeededRecursive();
890 ```
891
892 ###### Wrong:
893
894 ```cpp
895 const Vector<RefPtr<FrameView> >::iterator end = frameViews.end();
896 for (Vector<RefPtr<FrameView> >::iterator it = frameViews.begin(); it != end; ++it)
897     (*it)->updateLayoutAndStyleIfNeededRecursive();
898 ```
899
900 [](#punctuation-omit-lambda-paren) Omit parentheses for a C++ lambda whenever possible.
901
902 ###### Right:
903
904 ```cpp
905 [this] { return m_member; }
906 [this]() mutable { return doWork(WTFMove(m_object)); }
907 ```
908
909 ###### Wrong:
910
911 ```cpp
912 [this]() { return m_member; }
913 []() { return static_cast<unsigned>(-1); }
914 ```
915
916 ### Pointers and References
917
918 [](#pointers-non-cpp) **Pointer types in non-C++ code**
919 Pointer types should be written with a space between the type and the `*` (so the `*` is adjacent to the following identifier if any).
920
921 [](#pointers-cpp) **Pointer and reference types in C++ code**
922 Both pointer types and reference types should be written with no space between the type name and the `*` or `&`.
923
924 ###### Right:
925
926 ```cpp
927 Image* SVGStyledElement::doSomething(PaintInfo& paintInfo)
928 {
929     SVGStyledElement* element = static_cast<SVGStyledElement*>(node());
930     const KCDashArray& dashes = dashArray();
931 ```
932
933 ###### Wrong:
934
935 ```cpp
936 Image *SVGStyledElement::doSomething(PaintInfo &paintInfo)
937 {
938     SVGStyledElement *element = static_cast<SVGStyledElement *>(node());
939     const KCDashArray &dashes = dashArray();
940 ```
941
942 [](#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.
943
944 ###### Right:
945
946 ```cpp
947 void MyClass::getSomeValue(OutArgumentType& outArgument) const
948 {
949     outArgument = m_value;
950 }
951
952 void MyClass::doSomething(OutArgumentType* outArgument) const
953 {
954     doSomething();
955     if (outArgument)
956         *outArgument = m_value;
957 }
958 ```
959
960 ###### Wrong:
961
962 ```cpp
963 void MyClass::getSomeValue(OutArgumentType* outArgument) const
964 {
965     *outArgument = m_value;
966 }
967 ```
968
969 ### #include Statements
970
971 [](#include-config-h) All implementation files must `#include` `config.h` first. Header files should never include `config.h`.
972
973 ###### Right:
974
975 ```cpp
976 // RenderLayer.h
977 #include "Node.h"
978 #include "RenderObject.h"
979 #include "RenderView.h"
980 ```
981
982 ###### Wrong:
983
984 ```cpp
985 // RenderLayer.h
986 #include "config.h"
987
988 #include "RenderObject.h"
989 #include "RenderView.h"
990 #include "Node.h"
991 ```
992
993 [](#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.
994
995 [](#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.
996
997 ###### Right:
998
999 ```cpp
1000 // HTMLDivElement.cpp
1001 #include "config.h"
1002 #include "HTMLDivElement.h"
1003
1004 #include "Attribute.h"
1005 #include "HTMLElement.h"
1006 #include "QualifiedName.h"
1007 ```
1008
1009 ###### Wrong:
1010
1011 ```cpp
1012 // HTMLDivElement.cpp
1013 #include "HTMLElement.h"
1014 #include "HTMLDivElement.h"
1015 #include "QualifiedName.h"
1016 #include "Attribute.h"
1017 ```
1018
1019 [](#include-system) Includes of system headers must come after includes of other headers.
1020
1021 ###### Right:
1022
1023 ```cpp
1024 // ConnectionQt.cpp
1025 #include "ArgumentEncoder.h"
1026 #include "ProcessLauncher.h"
1027 #include "WebPageProxyMessageKinds.h"
1028 #include "WorkItem.h"
1029 #include <QApplication>
1030 #include <QLocalServer>
1031 #include <QLocalSocket>
1032 ```
1033
1034 ###### Wrong:
1035
1036 ```cpp
1037 // ConnectionQt.cpp
1038 #include "ArgumentEncoder.h"
1039 #include "ProcessLauncher.h"
1040 #include <QApplication>
1041 #include <QLocalServer>
1042 #include <QLocalSocket>
1043 #include "WebPageProxyMessageKinds.h"
1044 #include "WorkItem.h"
1045 ```
1046
1047 ### "using" Statements
1048
1049 [](#using-in-headers) In header files, do not use "using" statements in namespace (or global) scope.
1050
1051 ###### Right:
1052
1053 ```cpp
1054 // wtf/Vector.h
1055
1056 namespace WTF {
1057
1058 class VectorBuffer {
1059     using std::min;
1060     ...
1061 };
1062
1063 } // namespace WTF
1064 ```
1065
1066 ###### Wrong:
1067
1068 ```cpp
1069 // wtf/Vector.h
1070
1071 namespace WTF {
1072
1073 using std::min;
1074
1075 class VectorBuffer {
1076     ...
1077 };
1078
1079 } // namespace WTF
1080 ```
1081
1082 [](#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.
1083
1084 ###### Right:
1085
1086 ```cpp
1087 // wtf/Vector.h
1088
1089 namespace WTF {
1090
1091 } // namespace WTF
1092
1093 using WTF::Vector;
1094 ```
1095
1096 ###### Wrong:
1097
1098 ```cpp
1099 // wtf/Vector.h
1100
1101 namespace WTF {
1102
1103 } // namespace WTF
1104
1105 using namespace WTF;
1106 ```
1107
1108 ###### Wrong:
1109
1110 ```cpp
1111 // runtime/JSObject.h
1112
1113 namespace WTF {
1114
1115 } // namespace WTF
1116
1117 using WTF::PlacementNewAdopt;
1118 ```
1119
1120 [](#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.
1121
1122 ###### Right:
1123
1124 ```cpp
1125 // HTMLBaseElement.cpp
1126
1127 namespace WebCore {
1128
1129   std::swap(a, b);
1130   c = std::numeric_limits<int>::max()
1131
1132 } // namespace WebCore
1133 ```
1134
1135 ###### Wrong:
1136
1137 ```cpp
1138 // HTMLBaseElement.cpp
1139
1140 using std::swap;
1141
1142 namespace WebCore {
1143
1144   swap(a, b);
1145
1146 } // namespace WebCore
1147 ```
1148
1149 ###### Wrong:
1150
1151 ```cpp
1152 // HTMLBaseElement.cpp
1153
1154 using namespace std;
1155
1156 namespace WebCore {
1157
1158   swap(a, b);
1159
1160 } // namespace WebCore
1161 ```
1162
1163 [](#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.
1164
1165 ###### Right:
1166
1167 ```cpp
1168 // HTMLBaseElement.cpp
1169
1170 namespace WebCore {
1171
1172 using namespace HTMLNames;
1173
1174 } // namespace WebCore
1175 ```
1176
1177 ###### Wrong:
1178
1179 ```cpp
1180 // HTMLBaseElement.cpp
1181
1182 using namespace WebCore::HTMLNames;
1183
1184 namespace WebCore {
1185
1186 } // namespace WebCore
1187 ```
1188
1189 [](#using-position) In implementation files, put all "using namespace" statements inside namespace definitions.
1190
1191 ###### Right:
1192
1193 ```cpp
1194 // HTMLSelectElement.cpp
1195
1196 namespace WebCore {
1197
1198 using namespace other;
1199
1200 } // namespace WebCore
1201 ```
1202
1203 ###### Wrong:
1204
1205 ```cpp
1206 // HTMLSelectElement.cpp
1207
1208 using namespace other;
1209
1210 namespace WebCore {
1211
1212 } // namespace WebCore
1213 ```
1214
1215 ### Types
1216
1217 [](#types-unsigned) Omit "int" when using "unsigned" modifier. Do not use "signed" modifier. Use "int" by itself instead.
1218
1219 ###### Right:
1220
1221 ```cpp
1222 unsigned a;
1223 int b;
1224 ```
1225
1226 ###### Wrong:
1227
1228 ```cpp
1229 unsigned int a; // Doesn't omit "int".
1230 signed b; // Uses "signed" instead of "int".
1231 signed int c; // Doesn't omit "signed".
1232 ```
1233
1234 ### Classes
1235
1236 [](#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.
1237
1238 ###### Right:
1239
1240 ```cpp
1241 class LargeInt {
1242 public:
1243     LargeInt(int);
1244 ...
1245
1246 class Vector {
1247 public:
1248     explicit Vector(int size); // Not a type conversion.
1249     Vector create(Array); // Costly conversion.
1250 ...
1251
1252 ```
1253
1254 ###### Wrong:
1255
1256 ```cpp
1257 class Task {
1258 public:
1259     Task(ScriptExecutionContext&); // Not a type conversion.
1260     explicit Task(); // No arguments.
1261     explicit Task(ScriptExecutionContext&, Other); // More than one argument.
1262 ...
1263 ```
1264
1265 ### Singleton pattern
1266
1267 [](#singleton-static-member) Use a static member function named "singleton()" to access the instance of the singleton.
1268
1269 ###### Right:
1270
1271 ```cpp
1272 class MySingleton {
1273 public:
1274     static MySingleton& singleton();
1275 ...
1276 ```
1277
1278 ###### Wrong:
1279
1280 ```cpp
1281 class MySingleton {
1282 public:
1283     static MySingleton& shared();
1284 ...
1285 ```
1286
1287 ###### Wrong:
1288
1289 ```cpp
1290 class MySingleton {
1291 ...
1292 };
1293
1294 MySingleton& mySingleton(); // free function.
1295 ```
1296
1297 ### Comments
1298
1299 [](#comments-eol) Use only _one_ space before end of line comments and in between sentences in comments.
1300
1301 ###### Right:
1302
1303 ```cpp
1304 f(a, b); // This explains why the function call was done. This is another sentence.
1305 ```
1306
1307 ###### Wrong:
1308
1309 ```cpp
1310 int i;    // This is a comment with several spaces before it, which is a non-conforming style.
1311 double f; // This is another comment.  There are two spaces before this sentence which is a non-conforming style.
1312 ```
1313
1314 [](#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`.
1315
1316 [](#comments-fixme) Use FIXME: (without attribution) to denote items that need to be addressed in the future.
1317
1318 ###### Right:
1319
1320 ```cpp
1321 drawJpg(); // FIXME: Make this code handle jpg in addition to the png support.
1322 ```
1323
1324 ###### Wrong:
1325
1326 ```cpp
1327 drawJpg(); // FIXME(joe): Make this code handle jpg in addition to the png support.
1328 ```
1329
1330 ```cpp
1331 drawJpg(); // TODO: Make this code handle jpg in addition to the png support.
1332 ```
1333
1334 ### Overriding Virtual Methods
1335
1336 [](#override-methods) The base level declaration of a virtual method inside a class must be declared with the `virtual` keyword. All subclasses of that class must either specify the `override` keyword when overriding the virtual method or the `final` keyword when overriding the virtual method and requiring that no further subclasses can override it. You never want to annotate a method with more than one of the `virtual`, `override`, or `final` keywords.
1337
1338 ###### Right:
1339
1340 ```cpp
1341 class Person {
1342 public:
1343     virtual String description() { ... };
1344 }
1345
1346 class Student : public Person {
1347 public:
1348     String description() override { ... }; // This is correct because it only contains the "override" keyword to indicate that the method is overridden.
1349 }
1350
1351 ```
1352
1353 ```cpp
1354 class Person {
1355 public:
1356     virtual String description() { ... };
1357 }
1358
1359 class Student : public Person {
1360 public:
1361     String description() final { ... }; // This is correct because it only contains the "final" keyword to indicate that the method is overridden and that no subclasses of "Student" can override "description".
1362 }
1363
1364 ```
1365
1366 ###### Wrong:
1367
1368 ```cpp
1369 class Person {
1370 public:
1371     virtual String description() { ... };
1372 }
1373
1374 class Student : public Person {
1375 public:
1376     virtual String description() override { ... }; // This is incorrect because it uses both the "virtual" and "override" keywords to indicate that the method is overridden. Instead, it should only use the "override" keyword.
1377 }
1378 ```
1379
1380 ```cpp
1381 class Person {
1382 public:
1383     virtual String description() { ... };
1384 }
1385
1386 class Student : public Person {
1387 public:
1388     virtual String description() final { ... }; // This is incorrect because it uses both the "virtual" and "final" keywords to indicate that the method is overridden and final. Instead, it should only use the "final" keyword.
1389 }
1390 ```
1391
1392 ```cpp
1393 class Person {
1394 public:
1395     virtual String description() { ... };
1396 }
1397
1398 class Student : public Person {
1399 public:
1400     virtual String description() { ... }; // This is incorrect because it uses the "virtual" keyword to indicate that the method is overridden.
1401 }
1402 ```
1403
1404 ### Python
1405
1406 [](#python) For Python use PEP8 style.