Changeset 261567 in webkit


Ignore:
Timestamp:
May 12, 2020 11:48:02 AM (4 years ago)
Author:
Ross Kirsling
Message:

[clang-tidy] Run modernize-use-override over JSC, then ensure as much as possible is final
https://bugs.webkit.org/show_bug.cgi?id=211743

Reviewed by Saam Barati.

  • API/JSScriptRef.cpp:
  • b3/B3ArgumentRegValue.h:
  • b3/B3AtomicValue.h:
  • b3/B3CCallValue.h:
  • b3/B3CheckSpecial.h:
  • b3/B3CheckValue.h:
  • b3/B3Const32Value.h:
  • b3/B3Const64Value.h:
  • b3/B3ConstDoubleValue.h:
  • b3/B3ConstFloatValue.h:
  • b3/B3DataSection.h:
  • b3/B3ExtractValue.h:
  • b3/B3FenceValue.h:
  • b3/B3MemoryValue.h:
  • b3/B3PatchpointSpecial.h:
  • b3/B3PatchpointValue.h:
  • b3/B3SlotBaseValue.h:
  • b3/B3StackmapSpecial.h:
  • b3/B3StackmapValue.h:
  • b3/B3SwitchValue.h:
  • b3/B3UpsilonValue.h:
  • b3/B3VariableValue.h:
  • b3/B3WasmAddressValue.h:
  • b3/B3WasmBoundsCheckValue.h:
  • b3/air/AirCCallSpecial.h:
  • b3/air/AirPrintSpecial.h:
  • bytecode/BytecodeDumper.h:
  • bytecode/GetterSetterAccessCase.h:
  • bytecode/InstanceOfAccessCase.h:
  • bytecode/IntrinsicGetterAccessCase.h:
  • bytecode/ModuleNamespaceAccessCase.h:
  • bytecode/ProxyableAccessCase.h:
  • bytecode/Watchpoint.h:
  • dfg/DFGFailedFinalizer.h:
  • dfg/DFGGraph.h:
  • dfg/DFGJITCode.h:
  • dfg/DFGJITFinalizer.h:
  • dfg/DFGToFTLDeferredCompilationCallback.h:
  • dfg/DFGToFTLForOSREntryDeferredCompilationCallback.h:
  • ftl/FTLForOSREntryJITCode.h:
  • ftl/FTLJITCode.h:
  • ftl/FTLJITFinalizer.h:
  • heap/CompleteSubspace.h:
  • heap/FastMallocAlignedMemoryAllocator.h:
  • heap/GigacageAlignedMemoryAllocator.h:
  • heap/HeapSnapshotBuilder.h:
  • heap/IsoAlignedMemoryAllocator.h:
  • heap/IsoSubspace.h:
  • heap/IsoSubspacePerVM.cpp:
  • heap/IsoSubspacePerVM.h:
  • heap/MarkStackMergingConstraint.h:
  • heap/SimpleMarkingConstraint.h:
  • heap/SpaceTimeMutatorScheduler.h:
  • heap/StochasticSpaceTimeMutatorScheduler.h:
  • heap/SynchronousStopTheWorldMutatorScheduler.h:
  • jit/GCAwareJITStubRoutine.h:
  • jit/JITCode.h:
  • jit/JITThunks.h:
  • jit/JITToDFGDeferredCompilationCallback.h:
  • jit/PolymorphicCallStubRoutine.h:
  • jsc.cpp:
  • parser/Lexer.cpp: Address warning.
  • runtime/JSDestructibleObjectHeapCellType.h:
  • runtime/SimpleTypedArrayController.h:
  • runtime/Structure.h:
  • runtime/WeakGCMap.h:
  • wasm/WasmEntryPlan.h:
Location:
trunk/Source/JavaScriptCore
Files:
68 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/API/JSScriptRef.cpp

    r261556 r261567  
    4040using namespace JSC;
    4141
    42 struct OpaqueJSScript : public SourceProvider {
     42struct OpaqueJSScript final : public SourceProvider {
    4343public:
    4444    static WTF::Ref<OpaqueJSScript> create(VM& vm, const SourceOrigin& sourceOrigin, URL&& url, int startingLineNumber, const String& source)
     
    4747    }
    4848
    49     unsigned hash() const override
     49    unsigned hash() const final
    5050    {
    5151        return m_source.get().hash();
    5252    }
    5353
    54     StringView source() const override
     54    StringView source() const final
    5555    {
    5656        return m_source.get();
     
    6767    }
    6868
    69     virtual ~OpaqueJSScript() { }
     69    ~OpaqueJSScript() final { }
    7070
    7171    VM& m_vm;
  • trunk/Source/JavaScriptCore/ChangeLog

    r261564 r261567  
     12020-05-12  Ross Kirsling  <ross.kirsling@sony.com>
     2
     3        [clang-tidy] Run modernize-use-override over JSC, then ensure as much as possible is final
     4        https://bugs.webkit.org/show_bug.cgi?id=211743
     5
     6        Reviewed by Saam Barati.
     7
     8        * API/JSScriptRef.cpp:
     9        * b3/B3ArgumentRegValue.h:
     10        * b3/B3AtomicValue.h:
     11        * b3/B3CCallValue.h:
     12        * b3/B3CheckSpecial.h:
     13        * b3/B3CheckValue.h:
     14        * b3/B3Const32Value.h:
     15        * b3/B3Const64Value.h:
     16        * b3/B3ConstDoubleValue.h:
     17        * b3/B3ConstFloatValue.h:
     18        * b3/B3DataSection.h:
     19        * b3/B3ExtractValue.h:
     20        * b3/B3FenceValue.h:
     21        * b3/B3MemoryValue.h:
     22        * b3/B3PatchpointSpecial.h:
     23        * b3/B3PatchpointValue.h:
     24        * b3/B3SlotBaseValue.h:
     25        * b3/B3StackmapSpecial.h:
     26        * b3/B3StackmapValue.h:
     27        * b3/B3SwitchValue.h:
     28        * b3/B3UpsilonValue.h:
     29        * b3/B3VariableValue.h:
     30        * b3/B3WasmAddressValue.h:
     31        * b3/B3WasmBoundsCheckValue.h:
     32        * b3/air/AirCCallSpecial.h:
     33        * b3/air/AirPrintSpecial.h:
     34        * bytecode/BytecodeDumper.h:
     35        * bytecode/GetterSetterAccessCase.h:
     36        * bytecode/InstanceOfAccessCase.h:
     37        * bytecode/IntrinsicGetterAccessCase.h:
     38        * bytecode/ModuleNamespaceAccessCase.h:
     39        * bytecode/ProxyableAccessCase.h:
     40        * bytecode/Watchpoint.h:
     41        * dfg/DFGFailedFinalizer.h:
     42        * dfg/DFGGraph.h:
     43        * dfg/DFGJITCode.h:
     44        * dfg/DFGJITFinalizer.h:
     45        * dfg/DFGToFTLDeferredCompilationCallback.h:
     46        * dfg/DFGToFTLForOSREntryDeferredCompilationCallback.h:
     47        * ftl/FTLForOSREntryJITCode.h:
     48        * ftl/FTLJITCode.h:
     49        * ftl/FTLJITFinalizer.h:
     50        * heap/CompleteSubspace.h:
     51        * heap/FastMallocAlignedMemoryAllocator.h:
     52        * heap/GigacageAlignedMemoryAllocator.h:
     53        * heap/HeapSnapshotBuilder.h:
     54        * heap/IsoAlignedMemoryAllocator.h:
     55        * heap/IsoSubspace.h:
     56        * heap/IsoSubspacePerVM.cpp:
     57        * heap/IsoSubspacePerVM.h:
     58        * heap/MarkStackMergingConstraint.h:
     59        * heap/SimpleMarkingConstraint.h:
     60        * heap/SpaceTimeMutatorScheduler.h:
     61        * heap/StochasticSpaceTimeMutatorScheduler.h:
     62        * heap/SynchronousStopTheWorldMutatorScheduler.h:
     63        * jit/GCAwareJITStubRoutine.h:
     64        * jit/JITCode.h:
     65        * jit/JITThunks.h:
     66        * jit/JITToDFGDeferredCompilationCallback.h:
     67        * jit/PolymorphicCallStubRoutine.h:
     68        * jsc.cpp:
     69        * parser/Lexer.cpp: Address warning.
     70        * runtime/JSDestructibleObjectHeapCellType.h:
     71        * runtime/SimpleTypedArrayController.h:
     72        * runtime/Structure.h:
     73        * runtime/WeakGCMap.h:
     74        * wasm/WasmEntryPlan.h:
     75
    1762020-05-12  Michael Catanzaro  <mcatanzaro@gnome.org>
    277
  • trunk/Source/JavaScriptCore/b3/B3ArgumentRegValue.h

    r261556 r261567  
    3333namespace JSC { namespace B3 {
    3434
    35 class JS_EXPORT_PRIVATE ArgumentRegValue : public Value {
     35class JS_EXPORT_PRIVATE ArgumentRegValue final : public Value {
    3636public:
    3737    static bool accepts(Kind kind) { return kind == ArgumentReg; }
    3838   
    39     ~ArgumentRegValue();
     39    ~ArgumentRegValue() final;
    4040
    4141    Reg argumentReg() const { return m_reg; }
     
    4343    B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN
    4444
    45 protected:
    46     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     45private:
     46    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    4747
    48 private:
    4948    friend class Procedure;
    5049    friend class Value;
  • trunk/Source/JavaScriptCore/b3/B3AtomicValue.h

    r261556 r261567  
    3333namespace JSC { namespace B3 {
    3434
    35 class JS_EXPORT_PRIVATE AtomicValue : public MemoryValue {
     35class JS_EXPORT_PRIVATE AtomicValue final : public MemoryValue {
    3636public:
    3737    static bool accepts(Kind kind)
     
    4040    }
    4141   
    42     ~AtomicValue();
     42    ~AtomicValue() final;
    4343   
    4444    Type accessType() const { return child(0)->type(); }
     
    4848    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    4949   
    50 protected:
    51     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     50private:
     51    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    5252
    53 private:
    5453    friend class Procedure;
    5554    friend class Value;
  • trunk/Source/JavaScriptCore/b3/B3CCallValue.h

    r261556 r261567  
    3333namespace JSC { namespace B3 {
    3434
    35 class JS_EXPORT_PRIVATE CCallValue : public Value {
     35class JS_EXPORT_PRIVATE CCallValue final : public Value {
    3636public:
    3737    static bool accepts(Kind kind) { return kind == CCall; }
    3838
    39     ~CCallValue();
     39    ~CCallValue() final;
    4040
    4141    void appendArgs(const Vector<Value*>&);
  • trunk/Source/JavaScriptCore/b3/B3CheckSpecial.h

    r261556 r261567  
    4949// - CheckMul(a, b), which turns into Mul32 b, a but we pass Any for a's ValueRep.
    5050
    51 class CheckSpecial : public StackmapSpecial {
     51class CheckSpecial final : public StackmapSpecial {
    5252public:
    5353    // Support for hash consing these things.
     
    114114    CheckSpecial(Air::Kind, unsigned numArgs, RoleMode stackmapRole = SameAsRep);
    115115    CheckSpecial(const Key&);
    116     ~CheckSpecial();
     116    ~CheckSpecial() final;
    117117
    118 protected:
     118private:
    119119    // Constructs and returns the Inst representing the branch that this will use.
    120120    Air::Inst hiddenBranch(const Air::Inst&) const;
     
    134134    void deepDumpImpl(PrintStream&) const final;
    135135
    136 private:
    137136    Air::Kind m_checkKind;
    138137    RoleMode m_stackmapRole;
  • trunk/Source/JavaScriptCore/b3/B3CheckValue.h

    r261556 r261567  
    3232namespace JSC { namespace B3 {
    3333
    34 class CheckValue : public StackmapValue {
     34class CheckValue final : public StackmapValue {
    3535public:
    3636    static bool accepts(Kind kind)
     
    4747    }
    4848
    49     ~CheckValue();
     49    ~CheckValue() final;
    5050
    5151    void convertToAdd();
  • trunk/Source/JavaScriptCore/b3/B3Const32Value.h

    r261556 r261567  
    3636    static bool accepts(Kind kind) { return kind == Const32; }
    3737   
    38     ~Const32Value();
     38    ~Const32Value() override;
    3939   
    4040    int32_t value() const { return m_value; }
  • trunk/Source/JavaScriptCore/b3/B3Const64Value.h

    r261556 r261567  
    3636    static bool accepts(Kind kind) { return kind == Const64; }
    3737   
    38     ~Const64Value();
     38    ~Const64Value() override;
    3939   
    4040    int64_t value() const { return m_value; }
  • trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h

    r261556 r261567  
    3232namespace JSC { namespace B3 {
    3333
    34 class JS_EXPORT_PRIVATE ConstDoubleValue : public Value {
     34class JS_EXPORT_PRIVATE ConstDoubleValue final : public Value {
    3535public:
    3636    static bool accepts(Kind kind) { return kind == ConstDouble; }
    3737   
    38     ~ConstDoubleValue();
     38    ~ConstDoubleValue() final;
    3939   
    4040    double value() const { return m_value; }
    4141
    42     Value* negConstant(Procedure&) const override;
    43     Value* addConstant(Procedure&, int32_t other) const override;
    44     Value* addConstant(Procedure&, const Value* other) const override;
    45     Value* subConstant(Procedure&, const Value* other) const override;
    46     Value* divConstant(Procedure&, const Value* other) const override;
    47     Value* modConstant(Procedure&, const Value* other) const override;
    48     Value* mulConstant(Procedure&, const Value* other) const override;
    49     Value* bitAndConstant(Procedure&, const Value* other) const override;
    50     Value* bitOrConstant(Procedure&, const Value* other) const override;
    51     Value* bitXorConstant(Procedure&, const Value* other) const override;
    52     Value* bitwiseCastConstant(Procedure&) const override;
    53     Value* doubleToFloatConstant(Procedure&) const override;
    54     Value* absConstant(Procedure&) const override;
    55     Value* ceilConstant(Procedure&) const override;
    56     Value* floorConstant(Procedure&) const override;
    57     Value* sqrtConstant(Procedure&) const override;
     42    Value* negConstant(Procedure&) const final;
     43    Value* addConstant(Procedure&, int32_t other) const final;
     44    Value* addConstant(Procedure&, const Value* other) const final;
     45    Value* subConstant(Procedure&, const Value* other) const final;
     46    Value* divConstant(Procedure&, const Value* other) const final;
     47    Value* modConstant(Procedure&, const Value* other) const final;
     48    Value* mulConstant(Procedure&, const Value* other) const final;
     49    Value* bitAndConstant(Procedure&, const Value* other) const final;
     50    Value* bitOrConstant(Procedure&, const Value* other) const final;
     51    Value* bitXorConstant(Procedure&, const Value* other) const final;
     52    Value* bitwiseCastConstant(Procedure&) const final;
     53    Value* doubleToFloatConstant(Procedure&) const final;
     54    Value* absConstant(Procedure&) const final;
     55    Value* ceilConstant(Procedure&) const final;
     56    Value* floorConstant(Procedure&) const final;
     57    Value* sqrtConstant(Procedure&) const final;
    5858
    59     TriState equalConstant(const Value* other) const override;
    60     TriState notEqualConstant(const Value* other) const override;
    61     TriState lessThanConstant(const Value* other) const override;
    62     TriState greaterThanConstant(const Value* other) const override;
    63     TriState lessEqualConstant(const Value* other) const override;
    64     TriState greaterEqualConstant(const Value* other) const override;
    65     TriState equalOrUnorderedConstant(const Value* other) const override;
     59    TriState equalConstant(const Value* other) const final;
     60    TriState notEqualConstant(const Value* other) const final;
     61    TriState lessThanConstant(const Value* other) const final;
     62    TriState greaterThanConstant(const Value* other) const final;
     63    TriState lessEqualConstant(const Value* other) const final;
     64    TriState greaterEqualConstant(const Value* other) const final;
     65    TriState equalOrUnorderedConstant(const Value* other) const final;
    6666
    6767    B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN
     
    7171    friend class Value;
    7272
    73     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     73    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    7474
    7575    static Opcode opcodeFromConstructor(Origin, double) { return ConstDouble; }
  • trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h

    r261556 r261567  
    3232namespace JSC { namespace B3 {
    3333
    34 class JS_EXPORT_PRIVATE ConstFloatValue : public Value {
     34class JS_EXPORT_PRIVATE ConstFloatValue final : public Value {
    3535public:
    3636    static bool accepts(Kind kind) { return kind == ConstFloat; }
    3737
    38     ~ConstFloatValue();
     38    ~ConstFloatValue() final;
    3939
    4040    float value() const { return m_value; }
    4141
    42     Value* negConstant(Procedure&) const override;
    43     Value* addConstant(Procedure&, int32_t other) const override;
    44     Value* addConstant(Procedure&, const Value* other) const override;
    45     Value* subConstant(Procedure&, const Value* other) const override;
    46     Value* divConstant(Procedure&, const Value* other) const override;
    47     Value* mulConstant(Procedure&, const Value* other) const override;
    48     Value* bitAndConstant(Procedure&, const Value* other) const override;
    49     Value* bitOrConstant(Procedure&, const Value* other) const override;
    50     Value* bitXorConstant(Procedure&, const Value* other) const override;
    51     Value* bitwiseCastConstant(Procedure&) const override;
    52     Value* floatToDoubleConstant(Procedure&) const override;
    53     Value* absConstant(Procedure&) const override;
    54     Value* ceilConstant(Procedure&) const override;
    55     Value* floorConstant(Procedure&) const override;
    56     Value* sqrtConstant(Procedure&) const override;
     42    Value* negConstant(Procedure&) const final;
     43    Value* addConstant(Procedure&, int32_t other) const final;
     44    Value* addConstant(Procedure&, const Value* other) const final;
     45    Value* subConstant(Procedure&, const Value* other) const final;
     46    Value* divConstant(Procedure&, const Value* other) const final;
     47    Value* mulConstant(Procedure&, const Value* other) const final;
     48    Value* bitAndConstant(Procedure&, const Value* other) const final;
     49    Value* bitOrConstant(Procedure&, const Value* other) const final;
     50    Value* bitXorConstant(Procedure&, const Value* other) const final;
     51    Value* bitwiseCastConstant(Procedure&) const final;
     52    Value* floatToDoubleConstant(Procedure&) const final;
     53    Value* absConstant(Procedure&) const final;
     54    Value* ceilConstant(Procedure&) const final;
     55    Value* floorConstant(Procedure&) const final;
     56    Value* sqrtConstant(Procedure&) const final;
    5757
    58     TriState equalConstant(const Value* other) const override;
    59     TriState notEqualConstant(const Value* other) const override;
    60     TriState lessThanConstant(const Value* other) const override;
    61     TriState greaterThanConstant(const Value* other) const override;
    62     TriState lessEqualConstant(const Value* other) const override;
    63     TriState greaterEqualConstant(const Value* other) const override;
    64     TriState equalOrUnorderedConstant(const Value* other) const override;
     58    TriState equalConstant(const Value* other) const final;
     59    TriState notEqualConstant(const Value* other) const final;
     60    TriState lessThanConstant(const Value* other) const final;
     61    TriState greaterThanConstant(const Value* other) const final;
     62    TriState lessEqualConstant(const Value* other) const final;
     63    TriState greaterEqualConstant(const Value* other) const final;
     64    TriState equalOrUnorderedConstant(const Value* other) const final;
    6565
    6666    B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN
     
    7070    friend class Value;
    7171
    72     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     72    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    7373
    7474    static Opcode opcodeFromConstructor(Origin, float) { return ConstFloat; }
  • trunk/Source/JavaScriptCore/b3/B3DataSection.h

    r261556 r261567  
    3232namespace JSC { namespace B3 {
    3333
    34 class DataSection : public OpaqueByproduct {
     34class DataSection final : public OpaqueByproduct {
    3535public:
    3636    DataSection(size_t size);
    37     virtual ~DataSection();
     37    ~DataSection() final;
    3838
    3939    void* data() const { return m_data; }
    4040    size_t size() const { return m_size; }
    4141
    42     void dump(PrintStream&) const override;
     42    void dump(PrintStream&) const final;
    4343
    4444private:
  • trunk/Source/JavaScriptCore/b3/B3ExtractValue.h

    r261556 r261567  
    3636    static bool accepts(Kind kind) { return kind == Extract; }
    3737
    38     ~ExtractValue();
     38    ~ExtractValue() final;
    3939
    4040    int32_t index() const { return m_index; }
     
    4444
    4545private:
    46     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     46    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    4747
    4848    static Opcode opcodeFromConstructor(Origin, Type, Value*, int32_t) { return Extract; }
  • trunk/Source/JavaScriptCore/b3/B3FenceValue.h

    r261556 r261567  
    3333namespace JSC { namespace B3 {
    3434
    35 class JS_EXPORT_PRIVATE FenceValue : public Value {
     35class JS_EXPORT_PRIVATE FenceValue final : public Value {
    3636public:
    3737    static bool accepts(Kind kind) { return kind == Fence; }
    3838   
    39     ~FenceValue();
     39    ~FenceValue() final;
    4040   
    4141    // The read/write heaps are reflected in the effects() of this value. The compiler may change
  • trunk/Source/JavaScriptCore/b3/B3MemoryValue.h

    r261556 r261567  
    4242    }
    4343
    44     ~MemoryValue();
     44    ~MemoryValue() override;
    4545
    4646    OffsetType offset() const { return m_offset; }
  • trunk/Source/JavaScriptCore/b3/B3PatchpointSpecial.h

    r261556 r261567  
    4242//     Patch &patchpoint, result, args...
    4343
    44 class PatchpointSpecial : public StackmapSpecial {
     44class PatchpointSpecial final : public StackmapSpecial {
    4545public:
    4646    JS_EXPORT_PRIVATE PatchpointSpecial();
    47     virtual ~PatchpointSpecial();
     47    JS_EXPORT_PRIVATE ~PatchpointSpecial() final;
    4848
    49 protected:
     49private:
    5050    void forEachArg(Air::Inst&, const ScopedLambda<Air::Inst::EachArgCallback>&) final;
    5151    bool isValid(Air::Inst&) final;
  • trunk/Source/JavaScriptCore/b3/B3PatchpointValue.h

    r261556 r261567  
    3434namespace JSC { namespace B3 {
    3535
    36 class PatchpointValue : public StackmapValue {
     36class PatchpointValue final : public StackmapValue {
    3737public:
    3838    typedef StackmapValue Base;
     
    4040    static bool accepts(Kind kind) { return kind == Patchpoint; }
    4141
    42     ~PatchpointValue();
     42    ~PatchpointValue() final;
    4343
    4444    // The effects of the patchpoint. This defaults to Effects::forCall(), but you can set it to anything.
     
    6565    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_VARARGS_CHILDREN
    6666
    67 protected:
    68     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     67private:
     68    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    6969
    70 private:
    7170    friend class Procedure;
    7271    friend class Value;
  • trunk/Source/JavaScriptCore/b3/B3SlotBaseValue.h

    r261556 r261567  
    3434class StackSlot;
    3535
    36 class JS_EXPORT_PRIVATE SlotBaseValue : public Value {
     36class JS_EXPORT_PRIVATE SlotBaseValue final : public Value {
    3737public:
    3838    static bool accepts(Kind kind) { return kind == SlotBase; }
    3939
    40     ~SlotBaseValue();
     40    ~SlotBaseValue() final;
    4141
    4242    StackSlot* slot() const { return m_slot; }
     
    4848    friend class Value;
    4949
    50     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     50    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    5151
    5252    static Opcode opcodeFromConstructor(Origin, StackSlot*) { return SlotBase; }
  • trunk/Source/JavaScriptCore/b3/B3StackmapSpecial.h

    r261556 r261567  
    4343public:
    4444    StackmapSpecial();
    45     virtual ~StackmapSpecial();
     45    ~StackmapSpecial() override;
    4646
    4747    enum RoleMode : int8_t {
  • trunk/Source/JavaScriptCore/b3/B3StackmapValue.h

    r261556 r261567  
    6262    }
    6363
    64     ~StackmapValue();
     64    ~StackmapValue() override;
    6565
    6666    // Use this to add children.
  • trunk/Source/JavaScriptCore/b3/B3SwitchValue.h

    r261556 r261567  
    3434namespace JSC { namespace B3 {
    3535
    36 class SwitchValue : public Value {
     36class SwitchValue final : public Value {
    3737public:
    3838    static bool accepts(Kind kind) { return kind == Switch; }
    3939
    40     ~SwitchValue();
     40    ~SwitchValue() final;
    4141
    4242    // numCaseValues() + 1 == numSuccessors().
     
    6363    JS_EXPORT_PRIVATE void appendCase(const SwitchCase&);
    6464
    65     void dumpSuccessors(const BasicBlock*, PrintStream&) const override;
     65    void dumpSuccessors(const BasicBlock*, PrintStream&) const final;
    6666
    6767    B3_SPECIALIZE_VALUE_FOR_FIXED_CHILDREN(1)
    6868    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    6969
    70 protected:
    71     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     70private:
     71    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    7272
    73 private:
    7473    friend class Procedure;
    7574    friend class Value;
  • trunk/Source/JavaScriptCore/b3/B3UpsilonValue.h

    r261556 r261567  
    3232namespace JSC { namespace B3 {
    3333
    34 class JS_EXPORT_PRIVATE UpsilonValue : public Value {
     34class JS_EXPORT_PRIVATE UpsilonValue final : public Value {
    3535public:
    3636    static bool accepts(Kind kind) { return kind == Upsilon; }
    3737
    38     ~UpsilonValue();
     38    ~UpsilonValue() final;
    3939
    4040    Value* phi() const { return m_phi; }
     
    4949    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    5050
    51 protected:
    52     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     51private:
     52    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    5353
    54 private:
    5554    friend class Procedure;
    5655    friend class Value;
  • trunk/Source/JavaScriptCore/b3/B3VariableValue.h

    r261556 r261567  
    3434class Variable;
    3535
    36 class JS_EXPORT_PRIVATE VariableValue : public Value {
     36class JS_EXPORT_PRIVATE VariableValue final : public Value {
    3737public:
    3838    static bool accepts(Kind kind) { return kind == Get || kind == Set; }
    3939
    40     ~VariableValue();
     40    ~VariableValue() final;
    4141
    4242    Variable* variable() const { return m_variable; }
     
    4545    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    4646
    47 protected:
    48     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     47private:
     48    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    4949
    50 private:
    5150    friend class Procedure;
    5251    friend class Value;
  • trunk/Source/JavaScriptCore/b3/B3WasmAddressValue.h

    r261556 r261567  
    3333namespace JSC { namespace B3 {
    3434
    35 class JS_EXPORT_PRIVATE WasmAddressValue : public Value {
     35class JS_EXPORT_PRIVATE WasmAddressValue final : public Value {
    3636public:
    3737    static bool accepts(Kind kind) { return kind == WasmAddress; }
    3838
    39     ~WasmAddressValue();
     39    ~WasmAddressValue() final;
    4040
    4141    GPRReg pinnedGPR() const { return m_pinnedGPR; }
     
    4444    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    4545
    46 protected:
    47     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     46private:
     47    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    4848
    49 private:
    5049    friend class Procedure;
    5150    friend class Value;
  • trunk/Source/JavaScriptCore/b3/B3WasmBoundsCheckValue.h

    r261556 r261567  
    3333namespace JSC { namespace B3 {
    3434
    35 class WasmBoundsCheckValue : public Value {
     35class WasmBoundsCheckValue final : public Value {
    3636public:
    3737    static bool accepts(Kind kind) { return kind == WasmBoundsCheck; }
    3838   
    39     ~WasmBoundsCheckValue();
     39    ~WasmBoundsCheckValue() final;
    4040
    4141    enum class Type {
     
    5656    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    5757
    58 protected:
    59     void dumpMeta(CommaPrinter&, PrintStream&) const override;
     58private:
     59    void dumpMeta(CommaPrinter&, PrintStream&) const final;
    6060
    61 private:
    6261    friend class Procedure;
    6362    friend class Value;
  • trunk/Source/JavaScriptCore/b3/air/AirCCallSpecial.h

    r261556 r261567  
    4343// the prologue, whichever happened sooner.
    4444
    45 class CCallSpecial : public Special {
     45class CCallSpecial final : public Special {
    4646public:
    4747    CCallSpecial();
    48     ~CCallSpecial();
     48    ~CCallSpecial() final;
    4949
    5050    // You cannot use this register to pass arguments. It just so happens that this register is not
     
    5353    static constexpr GPRReg scratchRegister = GPRInfo::nonPreservedNonArgumentGPR0;
    5454
    55 protected:
     55private:
    5656    void forEachArg(Inst&, const ScopedLambda<Inst::EachArgCallback>&) final;
    5757    bool isValid(Inst&) final;
     
    6666    void deepDumpImpl(PrintStream&) const final;
    6767
    68 private:
    6968    static constexpr unsigned specialArgOffset = 0;
    7069    static constexpr unsigned numSpecialArgs = 1;
  • trunk/Source/JavaScriptCore/b3/air/AirPrintSpecial.h

    r261556 r261567  
    9393namespace B3 { namespace Air {
    9494
    95 class PrintSpecial : public Special {
     95class PrintSpecial final : public Special {
    9696public:
    9797    PrintSpecial(Printer::PrintRecordList*);
    98     ~PrintSpecial();
     98    ~PrintSpecial() final;
    9999   
    100100    // You cannot use this register to pass arguments. It just so happens that this register is not
     
    103103    static constexpr GPRReg scratchRegister = GPRInfo::nonArgGPR0;
    104104   
    105 protected:
     105private:
    106106    void forEachArg(Inst&, const ScopedLambda<Inst::EachArgCallback>&) final;
    107107    bool isValid(Inst&) final;
     
    116116    void deepDumpImpl(PrintStream&) const final;
    117117   
    118 private:
    119118    static constexpr unsigned specialArgOffset = 0;
    120119    static constexpr unsigned numSpecialArgs = 1;
  • trunk/Source/JavaScriptCore/bytecode/BytecodeDumper.h

    r261556 r261567  
    8585    }
    8686
    87     virtual ~BytecodeDumper() { }
     87    ~BytecodeDumper() override { }
    8888
    8989protected:
     
    102102
    103103template<class Block>
    104 class CodeBlockBytecodeDumper : public BytecodeDumper<Block> {
     104class CodeBlockBytecodeDumper final : public BytecodeDumper<Block> {
    105105public:
    106106    static void dumpBlock(Block*, const InstructionStream&, PrintStream& out, const ICStatusMap& = ICStatusMap());
     
    128128enum Type : int8_t;
    129129
    130 class BytecodeDumper : public JSC::BytecodeDumper<FunctionCodeBlock> {
     130class BytecodeDumper final : public JSC::BytecodeDumper<FunctionCodeBlock> {
    131131public:
    132132    static void dumpBlock(FunctionCodeBlock*, const ModuleInformation&, PrintStream& out);
     
    136136
    137137    void dumpConstants();
    138     CString constantName(VirtualRegister index) const override;
     138    CString constantName(VirtualRegister index) const final;
    139139    CString formatConstant(Type, uint64_t) const;
    140140};
  • trunk/Source/JavaScriptCore/bytecode/GetterSetterAccessCase.h

    r261556 r261567  
    3333namespace JSC {
    3434
    35 class GetterSetterAccessCase : public ProxyableAccessCase {
     35class GetterSetterAccessCase final : public ProxyableAccessCase {
    3636public:
    3737    typedef ProxyableAccessCase Base;
     
    4949    Optional<DOMAttributeAnnotation> domAttribute() const { return m_domAttribute; }
    5050
    51     bool hasAlternateBase() const override;
    52     JSObject* alternateBase() const override;
     51    bool hasAlternateBase() const final;
     52    JSObject* alternateBase() const final;
    5353
    5454    void emitDOMJITGetter(AccessGenerationState&, const DOMJIT::GetterSetter*, GPRReg baseForGetGPR);
     
    6363        FunctionPtr<OperationPtrTag> customSetter = nullptr, JSObject* customSlotBase = nullptr);
    6464
    65     void dumpImpl(PrintStream&, CommaPrinter&) const override;
    66     std::unique_ptr<AccessCase> clone() const override;
     65    void dumpImpl(PrintStream&, CommaPrinter&) const final;
     66    std::unique_ptr<AccessCase> clone() const final;
    6767
    68     ~GetterSetterAccessCase();
     68    ~GetterSetterAccessCase() final;
    6969
    7070    FunctionPtr<OperationPtrTag> customAccessor() const { return m_customAccessor; }
  • trunk/Source/JavaScriptCore/bytecode/InstanceOfAccessCase.h

    r261556 r261567  
    3232namespace JSC {
    3333
    34 class InstanceOfAccessCase : public AccessCase {
     34class InstanceOfAccessCase final : public AccessCase {
    3535public:
    3636    using Base = AccessCase;
     
    4242    JSObject* prototype() const { return m_prototype.get(); }
    4343   
    44     void dumpImpl(PrintStream&, CommaPrinter&) const override;
    45     std::unique_ptr<AccessCase> clone() const override;
     44    void dumpImpl(PrintStream&, CommaPrinter&) const final;
     45    std::unique_ptr<AccessCase> clone() const final;
    4646   
    47     ~InstanceOfAccessCase();
     47    ~InstanceOfAccessCase() final;
    4848
    49 protected:
     49private:
    5050    InstanceOfAccessCase(
    5151        VM&, JSCell*, AccessType, Structure*, const ObjectPropertyConditionSet&,
    5252        JSObject* prototype);
    5353
    54 private:
    5554    WriteBarrier<JSObject> m_prototype;
    5655};
  • trunk/Source/JavaScriptCore/bytecode/IntrinsicGetterAccessCase.h

    r261556 r261567  
    3232namespace JSC {
    3333
    34 class IntrinsicGetterAccessCase : public AccessCase {
     34class IntrinsicGetterAccessCase final : public AccessCase {
    3535public:
    3636    typedef AccessCase Base;
     
    4545    static std::unique_ptr<AccessCase> create(VM&, JSCell*, CacheableIdentifier, PropertyOffset, Structure*, const ObjectPropertyConditionSet&, JSFunction* intrinsicFunction, std::unique_ptr<PolyProtoAccessChain>);
    4646
    47     std::unique_ptr<AccessCase> clone() const override;
     47    std::unique_ptr<AccessCase> clone() const final;
    4848
    49     ~IntrinsicGetterAccessCase();
     49    ~IntrinsicGetterAccessCase() final;
    5050
    5151private:
  • trunk/Source/JavaScriptCore/bytecode/ModuleNamespaceAccessCase.h

    r261556 r261567  
    3636class JSModuleNamespaceObject;
    3737
    38 class ModuleNamespaceAccessCase : public AccessCase {
     38class ModuleNamespaceAccessCase final : public AccessCase {
    3939public:
    4040    using Base = AccessCase;
     
    4747    static std::unique_ptr<AccessCase> create(VM&, JSCell* owner, CacheableIdentifier, JSModuleNamespaceObject*, JSModuleEnvironment*, ScopeOffset);
    4848
    49     std::unique_ptr<AccessCase> clone() const override;
     49    std::unique_ptr<AccessCase> clone() const final;
    5050
    5151    void emit(AccessGenerationState&, MacroAssembler::JumpList& fallThrough);
    5252
    53     ~ModuleNamespaceAccessCase();
     53    ~ModuleNamespaceAccessCase() final;
    5454
    5555private:
  • trunk/Source/JavaScriptCore/bytecode/ProxyableAccessCase.h

    r261556 r261567  
    4444    std::unique_ptr<AccessCase> clone() const override;
    4545
    46     ~ProxyableAccessCase();
     46    ~ProxyableAccessCase() override;
    4747
    4848protected:
  • trunk/Source/JavaScriptCore/bytecode/Watchpoint.h

    r261556 r261567  
    534534public:
    535535    JS_EXPORT_PRIVATE DeferredWatchpointFire(VM&);
    536     JS_EXPORT_PRIVATE ~DeferredWatchpointFire();
     536    JS_EXPORT_PRIVATE ~DeferredWatchpointFire() override;
    537537
    538538    JS_EXPORT_PRIVATE void takeWatchpointsToFire(WatchpointSet*);
  • trunk/Source/JavaScriptCore/dfg/DFGFailedFinalizer.h

    r261556 r261567  
    3232namespace JSC { namespace DFG {
    3333
    34 class FailedFinalizer : public Finalizer {
     34class FailedFinalizer final : public Finalizer {
    3535public:
    3636    FailedFinalizer(Plan&);
    37     virtual ~FailedFinalizer();
     37    ~FailedFinalizer() final;
    3838   
    39     size_t codeSize() override;
    40     bool finalize() override;
    41     bool finalizeFunction() override;
     39    size_t codeSize() final;
     40    bool finalize() final;
     41    bool finalizeFunction() final;
    4242};
    4343
  • trunk/Source/JavaScriptCore/dfg/DFGGraph.h

    r261556 r261567  
    160160// The order may be significant for nodes with side-effects (property accesses, value conversions).
    161161// Nodes that are 'dead' remain in the vector with refCount 0.
    162 class Graph : public virtual Scannable {
     162class Graph final : public virtual Scannable {
    163163public:
    164164    Graph(VM&, Plan&);
    165     ~Graph();
     165    ~Graph() final;
    166166   
    167167    void changeChild(Edge& edge, Node* newNode)
     
    10021002    void registerFrozenValues();
    10031003   
    1004     void visitChildren(SlotVisitor&) override;
     1004    void visitChildren(SlotVisitor&) final;
    10051005   
    10061006    void logAssertionFailure(
  • trunk/Source/JavaScriptCore/dfg/DFGJITCode.h

    r261556 r261567  
    4747class JITCompiler;
    4848
    49 class JITCode : public DirectJITCode {
     49class JITCode final : public DirectJITCode {
    5050public:
    5151    JITCode();
    52     virtual ~JITCode();
     52    ~JITCode() final;
    5353   
    54     CommonData* dfgCommon() override;
    55     JITCode* dfg() override;
     54    CommonData* dfgCommon() final;
     55    JITCode* dfg() final;
    5656   
    5757    OSREntryData* appendOSREntryData(BytecodeIndex bytecodeIndex, CodeLocationLabel<OSREntryPtrTag> machineCode)
     
    114114#endif // ENABLE(FTL_JIT)
    115115   
    116     void validateReferences(const TrackedReferences&) override;
     116    void validateReferences(const TrackedReferences&) final;
    117117   
    118     void shrinkToFit(const ConcurrentJSLocker&) override;
     118    void shrinkToFit(const ConcurrentJSLocker&) final;
    119119
    120     RegisterSet liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock*, CallSiteIndex) override;
     120    RegisterSet liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock*, CallSiteIndex) final;
    121121#if ENABLE(FTL_JIT)
    122122    CodeBlock* osrEntryBlock() { return m_osrEntryBlock.get(); }
     
    127127    static ptrdiff_t commonDataOffset() { return OBJECT_OFFSETOF(JITCode, common); }
    128128
    129     Optional<CodeOrigin> findPC(CodeBlock*, void* pc) override;
     129    Optional<CodeOrigin> findPC(CodeBlock*, void* pc) final;
    130130
    131131    using DirectJITCode::initializeCodeRefForDFG;
  • trunk/Source/JavaScriptCore/dfg/DFGJITFinalizer.h

    r261556 r261567  
    3434namespace JSC { namespace DFG {
    3535
    36 class JITFinalizer : public Finalizer {
     36class JITFinalizer final : public Finalizer {
    3737public:
    3838    JITFinalizer(Plan&, Ref<JITCode>&&, std::unique_ptr<LinkBuffer>, MacroAssemblerCodePtr<JSEntryPtrTag> withArityCheck = MacroAssemblerCodePtr<JSEntryPtrTag>(MacroAssemblerCodePtr<JSEntryPtrTag>::EmptyValue));
    39     virtual ~JITFinalizer();
     39    ~JITFinalizer() final;
    4040   
    41     size_t codeSize() override;
    42     bool finalize() override;
    43     bool finalizeFunction() override;
     41    size_t codeSize() final;
     42    bool finalize() final;
     43    bool finalizeFunction() final;
    4444
    4545private:
  • trunk/Source/JavaScriptCore/dfg/DFGToFTLDeferredCompilationCallback.h

    r261556 r261567  
    3737namespace DFG {
    3838
    39 class ToFTLDeferredCompilationCallback : public DeferredCompilationCallback {
    40 protected:
    41     ToFTLDeferredCompilationCallback();
    42 
     39class ToFTLDeferredCompilationCallback final : public DeferredCompilationCallback {
    4340public:
    44     virtual ~ToFTLDeferredCompilationCallback();
     41    ~ToFTLDeferredCompilationCallback() final;
    4542
    4643    static Ref<ToFTLDeferredCompilationCallback> create();
    4744   
    48     virtual void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock);
    49     virtual void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult);
     45    void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) final;
     46    void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) final;
     47
     48private:
     49    ToFTLDeferredCompilationCallback();
    5050};
    5151
  • trunk/Source/JavaScriptCore/dfg/DFGToFTLForOSREntryDeferredCompilationCallback.h

    r261556 r261567  
    3838namespace DFG {
    3939
    40 class ToFTLForOSREntryDeferredCompilationCallback : public DeferredCompilationCallback {
    41 protected:
     40class ToFTLForOSREntryDeferredCompilationCallback final : public DeferredCompilationCallback {
     41public:
     42    ~ToFTLForOSREntryDeferredCompilationCallback() final;
     43
     44    static Ref<ToFTLForOSREntryDeferredCompilationCallback> create(JITCode::TriggerReason* forcedOSREntryTrigger);
     45
     46    void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) final;
     47    void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) final;
     48
     49private:
    4250    ToFTLForOSREntryDeferredCompilationCallback(JITCode::TriggerReason* forcedOSREntryTrigger);
    4351
    44 public:
    45     virtual ~ToFTLForOSREntryDeferredCompilationCallback();
    46 
    47     static Ref<ToFTLForOSREntryDeferredCompilationCallback> create(JITCode::TriggerReason* forcedOSREntryTrigger);
    48    
    49     virtual void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock);
    50     virtual void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult);
    51 
    52 private:
    5352    JITCode::TriggerReason* m_forcedOSREntryTrigger;
    5453};
  • trunk/Source/JavaScriptCore/ftl/FTLForOSREntryJITCode.h

    r261556 r261567  
    4141// - Each OSR entry compilation allows entry through only one bytecode index.
    4242
    43 class ForOSREntryJITCode : public FTL::JITCode {
     43class ForOSREntryJITCode final : public FTL::JITCode {
    4444public:
    4545    ForOSREntryJITCode();
    46     ~ForOSREntryJITCode();
     46    ~ForOSREntryJITCode() final;
    4747   
    4848    void initializeEntryBuffer(VM&, unsigned numCalleeLocals);
     
    5555    unsigned entryFailureCount() const { return m_entryFailureCount; }
    5656   
    57     ForOSREntryJITCode* ftlForOSREntry();
     57    ForOSREntryJITCode* ftlForOSREntry() final;
    5858   
    5959private:
  • trunk/Source/JavaScriptCore/ftl/FTLJITCode.h

    r261556 r261567  
    4343public:
    4444    JITCode();
    45     ~JITCode();
     45    ~JITCode() override;
    4646
    4747    CodePtr<JSEntryPtrTag> addressForCall(ArityCheckMode) override;
  • trunk/Source/JavaScriptCore/ftl/FTLJITFinalizer.h

    r261556 r261567  
    4848};
    4949
    50 class JITFinalizer : public DFG::Finalizer {
     50class JITFinalizer final : public DFG::Finalizer {
    5151public:
    5252    JITFinalizer(DFG::Plan&);
    53     virtual ~JITFinalizer();
     53    ~JITFinalizer() final;
    5454
    55     size_t codeSize() override;
    56     bool finalize() override;
    57     bool finalizeFunction() override;
     55    size_t codeSize() final;
     56    bool finalize() final;
     57    bool finalizeFunction() final;
    5858   
    5959    bool finalizeCommon();
  • trunk/Source/JavaScriptCore/heap/CompleteSubspace.h

    r261556 r261567  
    3030namespace JSC {
    3131
    32 class CompleteSubspace : public Subspace {
     32class CompleteSubspace final : public Subspace {
    3333public:
    3434    JS_EXPORT_PRIVATE CompleteSubspace(CString name, Heap&, HeapCellType*, AlignedMemoryAllocator*);
    35     JS_EXPORT_PRIVATE ~CompleteSubspace();
     35    JS_EXPORT_PRIVATE ~CompleteSubspace() final;
    3636
    3737    // In some code paths, we need it to be a compile error to call the virtual version of one of
     
    4040    // FIXME: Currently subspaces speak of BlockDirectories as "allocators", but that's temporary.
    4141    // https://bugs.webkit.org/show_bug.cgi?id=181559
    42     Allocator allocatorFor(size_t, AllocatorForMode) override;
     42    Allocator allocatorFor(size_t, AllocatorForMode) final;
    4343    Allocator allocatorForNonVirtual(size_t, AllocatorForMode);
    4444   
    45     void* allocate(VM&, size_t, GCDeferralContext*, AllocationFailureMode) override;
     45    void* allocate(VM&, size_t, GCDeferralContext*, AllocationFailureMode) final;
    4646    void* allocateNonVirtual(VM&, size_t, GCDeferralContext*, AllocationFailureMode);
    4747    void* reallocatePreciseAllocationNonVirtual(VM&, HeapCell*, size_t, GCDeferralContext*, AllocationFailureMode);
  • trunk/Source/JavaScriptCore/heap/FastMallocAlignedMemoryAllocator.h

    r261556 r261567  
    3434namespace JSC {
    3535
    36 class FastMallocAlignedMemoryAllocator : public AlignedMemoryAllocator {
     36class FastMallocAlignedMemoryAllocator final : public AlignedMemoryAllocator {
    3737public:
    3838    FastMallocAlignedMemoryAllocator();
    39     ~FastMallocAlignedMemoryAllocator();
     39    ~FastMallocAlignedMemoryAllocator() final;
    4040   
    41     void* tryAllocateAlignedMemory(size_t alignment, size_t size) override;
    42     void freeAlignedMemory(void*) override;
     41    void* tryAllocateAlignedMemory(size_t alignment, size_t size) final;
     42    void freeAlignedMemory(void*) final;
    4343   
    44     void dump(PrintStream&) const override;
     44    void dump(PrintStream&) const final;
    4545
    46     void* tryAllocateMemory(size_t) override;
    47     void freeMemory(void*) override;
    48     void* tryReallocateMemory(void*, size_t) override;
     46    void* tryAllocateMemory(size_t) final;
     47    void freeMemory(void*) final;
     48    void* tryReallocateMemory(void*, size_t) final;
    4949
    5050#if ENABLE(MALLOC_HEAP_BREAKDOWN)
  • trunk/Source/JavaScriptCore/heap/GigacageAlignedMemoryAllocator.h

    r261556 r261567  
    3535namespace JSC {
    3636
    37 class GigacageAlignedMemoryAllocator : public AlignedMemoryAllocator {
     37class GigacageAlignedMemoryAllocator final : public AlignedMemoryAllocator {
    3838public:
    3939    GigacageAlignedMemoryAllocator(Gigacage::Kind);
    40     ~GigacageAlignedMemoryAllocator();
     40    ~GigacageAlignedMemoryAllocator() final;
    4141   
    42     void* tryAllocateAlignedMemory(size_t alignment, size_t size) override;
    43     void freeAlignedMemory(void*) override;
     42    void* tryAllocateAlignedMemory(size_t alignment, size_t size) final;
     43    void freeAlignedMemory(void*) final;
    4444   
    45     void dump(PrintStream&) const override;
     45    void dump(PrintStream&) const final;
    4646
    47     void* tryAllocateMemory(size_t) override;
    48     void freeMemory(void*) override;
    49     void* tryReallocateMemory(void*, size_t) override;
     47    void* tryAllocateMemory(size_t) final;
     48    void freeMemory(void*) final;
     49    void* tryReallocateMemory(void*, size_t) final;
    5050
    5151private:
  • trunk/Source/JavaScriptCore/heap/HeapSnapshotBuilder.h

    r261556 r261567  
    109109
    110110    HeapSnapshotBuilder(HeapProfiler&, SnapshotType = SnapshotType::InspectorSnapshot);
    111     ~HeapSnapshotBuilder();
     111    ~HeapSnapshotBuilder() final;
    112112
    113113    static void resetNextAvailableObjectIdentifier();
     
    117117
    118118    // A root or marked cell.
    119     void analyzeNode(JSCell*);
     119    void analyzeNode(JSCell*) final;
    120120
    121121    // A reference from one cell to another.
    122     void analyzeEdge(JSCell* from, JSCell* to, SlotVisitor::RootMarkReason);
    123     void analyzePropertyNameEdge(JSCell* from, JSCell* to, UniquedStringImpl* propertyName);
    124     void analyzeVariableNameEdge(JSCell* from, JSCell* to, UniquedStringImpl* variableName);
    125     void analyzeIndexEdge(JSCell* from, JSCell* to, uint32_t index);
     122    void analyzeEdge(JSCell* from, JSCell* to, SlotVisitor::RootMarkReason) final;
     123    void analyzePropertyNameEdge(JSCell* from, JSCell* to, UniquedStringImpl* propertyName) final;
     124    void analyzeVariableNameEdge(JSCell* from, JSCell* to, UniquedStringImpl* variableName) final;
     125    void analyzeIndexEdge(JSCell* from, JSCell* to, uint32_t index) final;
    126126
    127     void setOpaqueRootReachabilityReasonForCell(JSCell*, const char*);
    128     void setWrappedObjectForCell(JSCell*, void*);
    129     void setLabelForCell(JSCell*, const String&);
     127    void setOpaqueRootReachabilityReasonForCell(JSCell*, const char*) final;
     128    void setWrappedObjectForCell(JSCell*, void*) final;
     129    void setLabelForCell(JSCell*, const String&) final;
    130130
    131131    String json();
  • trunk/Source/JavaScriptCore/heap/IsoAlignedMemoryAllocator.h

    r261556 r261567  
    3535namespace JSC {
    3636
    37 class IsoAlignedMemoryAllocator : public AlignedMemoryAllocator {
     37class IsoAlignedMemoryAllocator final : public AlignedMemoryAllocator {
    3838public:
    3939    IsoAlignedMemoryAllocator(CString);
    40     ~IsoAlignedMemoryAllocator();
     40    ~IsoAlignedMemoryAllocator() final;
    4141
    42     void* tryAllocateAlignedMemory(size_t alignment, size_t size) override;
    43     void freeAlignedMemory(void*) override;
     42    void* tryAllocateAlignedMemory(size_t alignment, size_t size) final;
     43    void freeAlignedMemory(void*) final;
    4444
    45     void dump(PrintStream&) const override;
     45    void dump(PrintStream&) const final;
    4646
    47     void* tryAllocateMemory(size_t) override;
    48     void freeMemory(void*) override;
    49     void* tryReallocateMemory(void*, size_t) override;
     47    void* tryAllocateMemory(size_t) final;
     48    void freeMemory(void*) final;
     49    void* tryReallocateMemory(void*, size_t) final;
    5050
    5151private:
  • trunk/Source/JavaScriptCore/heap/IsoSubspace.h

    r261556 r261567  
    3939public:
    4040    JS_EXPORT_PRIVATE IsoSubspace(CString name, Heap&, HeapCellType*, size_t size, uint8_t numberOfLowerTierCells);
    41     JS_EXPORT_PRIVATE ~IsoSubspace();
     41    JS_EXPORT_PRIVATE ~IsoSubspace() override;
    4242
    4343    size_t cellSize() { return m_directory.cellSize(); }
  • trunk/Source/JavaScriptCore/heap/IsoSubspacePerVM.cpp

    r261556 r261567  
    3232namespace JSC {
    3333
    34 class IsoSubspacePerVM::AutoremovingIsoSubspace : public IsoSubspace {
     34class IsoSubspacePerVM::AutoremovingIsoSubspace final : public IsoSubspace {
    3535public:
    3636    AutoremovingIsoSubspace(IsoSubspacePerVM& perVM, CString name, Heap& heap, HeapCellType* heapCellType, size_t size)
     
    4040    }
    4141   
    42     ~AutoremovingIsoSubspace()
     42    ~AutoremovingIsoSubspace() final
    4343    {
    4444        auto locker = holdLock(m_perVM.m_lock);
  • trunk/Source/JavaScriptCore/heap/IsoSubspacePerVM.h

    r261556 r261567  
    3737// once, then this is not great, because concurrent allocations will probably contend on this thing's
    3838// lock.
    39 class IsoSubspacePerVM {
     39class IsoSubspacePerVM final {
    4040public:
    4141    struct SubspaceParameters {
  • trunk/Source/JavaScriptCore/heap/MarkStackMergingConstraint.h

    r261556 r261567  
    3333class SlotVisitor;
    3434
    35 class MarkStackMergingConstraint : public MarkingConstraint {
     35class MarkStackMergingConstraint final : public MarkingConstraint {
    3636public:
    3737    MarkStackMergingConstraint(Heap&);
    38     ~MarkStackMergingConstraint();
     38    ~MarkStackMergingConstraint() final;
    3939   
    40     double quickWorkEstimate(SlotVisitor&) override;
    41    
    42 protected:
    43     void prepareToExecuteImpl(const AbstractLocker& constraintSolvingLocker, SlotVisitor&) override;
    44     void executeImpl(SlotVisitor&) override;
     40    double quickWorkEstimate(SlotVisitor&) final;
    4541   
    4642private:
     43    void prepareToExecuteImpl(const AbstractLocker& constraintSolvingLocker, SlotVisitor&) final;
     44    void executeImpl(SlotVisitor&) final;
     45   
    4746    Heap& m_heap;
    4847};
  • trunk/Source/JavaScriptCore/heap/SimpleMarkingConstraint.h

    r261556 r261567  
    3434// downside is that this makes it hard for constraints to override any functions in MarkingConstraint
    3535// other than executeImpl. In those cases, just subclass MarkingConstraint.
    36 class SimpleMarkingConstraint : public MarkingConstraint {
     36class SimpleMarkingConstraint final : public MarkingConstraint {
    3737public:
    3838    JS_EXPORT_PRIVATE SimpleMarkingConstraint(
     
    5252    }
    5353   
    54     JS_EXPORT_PRIVATE ~SimpleMarkingConstraint();
     54    JS_EXPORT_PRIVATE ~SimpleMarkingConstraint() final;
    5555   
    5656private:
    57     void executeImpl(SlotVisitor&) override;
     57    void executeImpl(SlotVisitor&) final;
    5858
    5959    ::Function<void(SlotVisitor&)> m_executeFunction;
  • trunk/Source/JavaScriptCore/heap/SpaceTimeMutatorScheduler.h

    r261556 r261567  
    3939// began.
    4040
    41 class SpaceTimeMutatorScheduler : public MutatorScheduler {
     41class SpaceTimeMutatorScheduler final : public MutatorScheduler {
    4242public:
    4343    SpaceTimeMutatorScheduler(Heap&);
    44     ~SpaceTimeMutatorScheduler();
     44    ~SpaceTimeMutatorScheduler() final;
    4545   
    46     State state() const override;
     46    State state() const final;
    4747   
    48     void beginCollection() override;
     48    void beginCollection() final;
    4949   
    50     void didStop() override;
    51     void willResume() override;
    52     void didExecuteConstraints() override;
     50    void didStop() final;
     51    void willResume() final;
     52    void didExecuteConstraints() final;
    5353   
    54     MonotonicTime timeToStop() override;
    55     MonotonicTime timeToResume() override;
     54    MonotonicTime timeToStop() final;
     55    MonotonicTime timeToResume() final;
    5656   
    57     void log() override;
     57    void log() final;
    5858   
    59     void endCollection() override;
     59    void endCollection() final;
    6060   
    6161private:
  • trunk/Source/JavaScriptCore/heap/StochasticSpaceTimeMutatorScheduler.h

    r261556 r261567  
    4040// began.
    4141
    42 class StochasticSpaceTimeMutatorScheduler : public MutatorScheduler {
     42class StochasticSpaceTimeMutatorScheduler final : public MutatorScheduler {
    4343public:
    4444    StochasticSpaceTimeMutatorScheduler(Heap&);
    45     ~StochasticSpaceTimeMutatorScheduler();
     45    ~StochasticSpaceTimeMutatorScheduler() final;
    4646   
    47     State state() const override;
     47    State state() const final;
    4848   
    49     void beginCollection() override;
     49    void beginCollection() final;
    5050   
    51     void didStop() override;
    52     void willResume() override;
    53     void didReachTermination() override;
    54     void didExecuteConstraints() override;
    55     void synchronousDrainingDidStall() override;
     51    void didStop() final;
     52    void willResume() final;
     53    void didReachTermination() final;
     54    void didExecuteConstraints() final;
     55    void synchronousDrainingDidStall() final;
    5656   
    57     MonotonicTime timeToStop() override;
    58     MonotonicTime timeToResume() override;
     57    MonotonicTime timeToStop() final;
     58    MonotonicTime timeToResume() final;
    5959   
    60     void log() override;
     60    void log() final;
    6161   
    62     void endCollection() override;
     62    void endCollection() final;
    6363   
    6464private:
  • trunk/Source/JavaScriptCore/heap/SynchronousStopTheWorldMutatorScheduler.h

    r261556 r261567  
    3636// SpaceTimeMutatorScheduler. It tells the GC to never resume the world once the GC cycle begins.
    3737
    38 class SynchronousStopTheWorldMutatorScheduler : public MutatorScheduler {
     38class SynchronousStopTheWorldMutatorScheduler final : public MutatorScheduler {
    3939public:
    4040    SynchronousStopTheWorldMutatorScheduler();
    41     ~SynchronousStopTheWorldMutatorScheduler();
     41    ~SynchronousStopTheWorldMutatorScheduler() final;
    4242   
    43     State state() const override;
     43    State state() const final;
    4444   
    45     void beginCollection() override;
     45    void beginCollection() final;
    4646   
    47     MonotonicTime timeToStop() override;
    48     MonotonicTime timeToResume() override;
     47    MonotonicTime timeToStop() final;
     48    MonotonicTime timeToResume() final;
    4949   
    50     void endCollection() override;
     50    void endCollection() final;
    5151
    5252private:
  • trunk/Source/JavaScriptCore/jit/GCAwareJITStubRoutine.h

    r261556 r261567  
    5252public:
    5353    GCAwareJITStubRoutine(const MacroAssemblerCodeRef<JITStubRoutinePtrTag>&, VM&);
    54     virtual ~GCAwareJITStubRoutine();
     54    ~GCAwareJITStubRoutine() override;
    5555
    5656    static Ref<JITStubRoutine> create(const MacroAssemblerCodeRef<JITStubRoutinePtrTag>& code, VM& vm)
     
    8484    MarkingGCAwareJITStubRoutine(
    8585        const MacroAssemblerCodeRef<JITStubRoutinePtrTag>&, VM&, const JSCell* owner, const Vector<JSCell*>&, Bag<CallLinkInfo>&&);
    86     virtual ~MarkingGCAwareJITStubRoutine();
     86    ~MarkingGCAwareJITStubRoutine() override;
    8787   
    8888protected:
     
    9898// handling table when it dies. It also frees space in CodeOrigin table
    9999// for new exception handlers to use the same DisposableCallSiteIndex.
    100 class GCAwareJITStubRoutineWithExceptionHandler : public MarkingGCAwareJITStubRoutine {
     100class GCAwareJITStubRoutineWithExceptionHandler final : public MarkingGCAwareJITStubRoutine {
    101101public:
    102102    typedef GCAwareJITStubRoutine Base;
     
    104104    GCAwareJITStubRoutineWithExceptionHandler(const MacroAssemblerCodeRef<JITStubRoutinePtrTag>&, VM&, const JSCell* owner, const Vector<JSCell*>&, Bag<CallLinkInfo>&&, CodeBlock*, DisposableCallSiteIndex);
    105105
    106     void aboutToDie() override;
    107     void observeZeroRefCount() override;
     106    void aboutToDie() final;
     107    void observeZeroRefCount() final;
    108108
    109109private:
  • trunk/Source/JavaScriptCore/jit/JITCode.h

    r261556 r261567  
    227227
    228228public:
    229     virtual ~JITCodeWithCodeRef();
     229    ~JITCodeWithCodeRef() override;
    230230
    231231    void* executableAddressAtOffset(size_t offset) override;
     
    246246    DirectJITCode(CodeRef<JSEntryPtrTag>, CodePtr<JSEntryPtrTag> withArityCheck, JITType, JITCode::ShareAttribute = JITCode::ShareAttribute::NotShared);
    247247    DirectJITCode(CodeRef<JSEntryPtrTag>, CodePtr<JSEntryPtrTag> withArityCheck, JITType, Intrinsic, JITCode::ShareAttribute = JITCode::ShareAttribute::NotShared); // For generated thunk.
    248     virtual ~DirectJITCode();
     248    ~DirectJITCode() override;
    249249   
    250250    CodePtr<JSEntryPtrTag> addressForCall(ArityCheckMode) override;
     
    261261    NativeJITCode(JITType);
    262262    NativeJITCode(CodeRef<JSEntryPtrTag>, JITType, Intrinsic, JITCode::ShareAttribute = JITCode::ShareAttribute::NotShared);
    263     virtual ~NativeJITCode();
     263    ~NativeJITCode() override;
    264264
    265265    CodePtr<JSEntryPtrTag> addressForCall(ArityCheckMode) override;
     
    269269public:
    270270    NativeDOMJITCode(CodeRef<JSEntryPtrTag>, JITType, Intrinsic, const DOMJIT::Signature*);
    271     virtual ~NativeDOMJITCode() = default;
    272 
    273     const DOMJIT::Signature* signature() const override { return m_signature; }
     271    ~NativeDOMJITCode() final = default;
     272
     273    const DOMJIT::Signature* signature() const final { return m_signature; }
    274274
    275275private:
  • trunk/Source/JavaScriptCore/jit/JITThunks.h

    r261556 r261567  
    5151public:
    5252    JITThunks();
    53     virtual ~JITThunks();
     53    ~JITThunks() final;
    5454
    5555    MacroAssemblerCodePtr<JITThunkPtrTag> ctiNativeCall(VM&);
     
    6868
    6969private:
    70     void finalize(Handle<Unknown>, void* context) override;
     70    void finalize(Handle<Unknown>, void* context) final;
    7171   
    7272    typedef HashMap<ThunkGenerator, MacroAssemblerCodeRef<JITThunkPtrTag>> CTIStubMap;
  • trunk/Source/JavaScriptCore/jit/JITToDFGDeferredCompilationCallback.h

    r261556 r261567  
    3434class ScriptExecutable;
    3535
    36 class JITToDFGDeferredCompilationCallback : public DeferredCompilationCallback {
    37 protected:
    38     JITToDFGDeferredCompilationCallback();
    39 
     36class JITToDFGDeferredCompilationCallback final : public DeferredCompilationCallback {
    4037public:
    41     virtual ~JITToDFGDeferredCompilationCallback();
     38    ~JITToDFGDeferredCompilationCallback() final;
    4239
    4340    static Ref<JITToDFGDeferredCompilationCallback> create();
    4441   
    45     void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) override;
    46     void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) override;
     42    void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) final;
     43    void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) final;
     44
     45private:
     46    JITToDFGDeferredCompilationCallback();
    4747};
    4848
  • trunk/Source/JavaScriptCore/jit/PolymorphicCallStubRoutine.h

    r261556 r261567  
    8181};
    8282
    83 class PolymorphicCallStubRoutine : public GCAwareJITStubRoutine {
     83class PolymorphicCallStubRoutine final : public GCAwareJITStubRoutine {
    8484public:
    8585    PolymorphicCallStubRoutine(
     
    8888        UniqueArray<uint32_t>&& fastCounts);
    8989   
    90     virtual ~PolymorphicCallStubRoutine();
     90    ~PolymorphicCallStubRoutine() final;
    9191   
    9292    CallVariantList variants() const;
     
    103103    }
    104104
    105     bool visitWeak(VM&) override;
    106 
    107 protected:
    108     void markRequiredObjectsInternal(SlotVisitor&) override;
     105    bool visitWeak(VM&) final;
    109106
    110107private:
     108    void markRequiredObjectsInternal(SlotVisitor&) final;
     109
    111110    Vector<WriteBarrier<JSCell>, 2> m_variants;
    112111    UniqueArray<uint32_t> m_fastCounts;
  • trunk/Source/JavaScriptCore/jsc.cpp

    r261556 r261567  
    973973}
    974974
    975 class ShellSourceProvider : public StringSourceProvider {
     975class ShellSourceProvider final : public StringSourceProvider {
    976976public:
    977977    static Ref<ShellSourceProvider> create(const String& source, const SourceOrigin& sourceOrigin, URL&& url, const TextPosition& startPosition, SourceProviderSourceType sourceType)
     
    980980    }
    981981
    982     ~ShellSourceProvider()
     982    ~ShellSourceProvider() final
    983983    {
    984984        commitCachedBytecode();
    985985    }
    986986
    987     RefPtr<CachedBytecode> cachedBytecode() const override
     987    RefPtr<CachedBytecode> cachedBytecode() const final
    988988    {
    989989        if (!m_cachedBytecode)
     
    992992    }
    993993
    994     void updateCache(const UnlinkedFunctionExecutable* executable, const SourceCode&, CodeSpecializationKind kind, const UnlinkedFunctionCodeBlock* codeBlock) const override
     994    void updateCache(const UnlinkedFunctionExecutable* executable, const SourceCode&, CodeSpecializationKind kind, const UnlinkedFunctionCodeBlock* codeBlock) const final
    995995    {
    996996        if (!cacheEnabled() || !m_cachedBytecode)
     
    10021002    }
    10031003
    1004     void cacheBytecode(const BytecodeCacheGenerator& generator) const override
     1004    void cacheBytecode(const BytecodeCacheGenerator& generator) const final
    10051005    {
    10061006        if (!cacheEnabled())
     
    10131013    }
    10141014
    1015     void commitCachedBytecode() const override
     1015    void commitCachedBytecode() const final
    10161016    {
    10171017        if (!cacheEnabled() || !m_cachedBytecode || !m_cachedBytecode->hasUpdates())
  • trunk/Source/JavaScriptCore/parser/Lexer.cpp

    r261556 r261567  
    747747}
    748748
    749 static ALWAYS_INLINE bool isSingleCharacterIdentStart(UChar c)
     749static ALWAYS_INLINE UNUSED_FUNCTION bool isSingleCharacterIdentStart(UChar c)
    750750{
    751751    if (LIKELY(isLatin1(c)))
  • trunk/Source/JavaScriptCore/runtime/JSDestructibleObjectHeapCellType.h

    r261556 r261567  
    3030namespace JSC {
    3131
    32 class JSDestructibleObjectHeapCellType : public HeapCellType {
     32class JSDestructibleObjectHeapCellType final : public HeapCellType {
    3333public:
    3434    JS_EXPORT_PRIVATE JSDestructibleObjectHeapCellType();
    35     JS_EXPORT_PRIVATE virtual ~JSDestructibleObjectHeapCellType();
     35    JS_EXPORT_PRIVATE ~JSDestructibleObjectHeapCellType() final;
    3636   
    37     void finishSweep(MarkedBlock::Handle&, FreeList*) override;
    38     void destroy(VM&, JSCell*) override;
     37    void finishSweep(MarkedBlock::Handle&, FreeList*) final;
     38    void destroy(VM&, JSCell*) final;
    3939};
    4040
  • trunk/Source/JavaScriptCore/runtime/SimpleTypedArrayController.h

    r261556 r261567  
    4747//   one.
    4848
    49 class SimpleTypedArrayController : public TypedArrayController {
     49class SimpleTypedArrayController final : public TypedArrayController {
    5050public:
    5151    SimpleTypedArrayController();
    52     virtual ~SimpleTypedArrayController();
     52    ~SimpleTypedArrayController() final;
    5353   
    54     JSArrayBuffer* toJS(JSGlobalObject*, JSGlobalObject*, ArrayBuffer*) override;
    55     void registerWrapper(JSGlobalObject*, ArrayBuffer*, JSArrayBuffer*) override;
    56     bool isAtomicsWaitAllowedOnCurrentThread() override;
     54    JSArrayBuffer* toJS(JSGlobalObject*, JSGlobalObject*, ArrayBuffer*) final;
     55    void registerWrapper(JSGlobalObject*, ArrayBuffer*, JSArrayBuffer*) final;
     56    bool isAtomicsWaitAllowedOnCurrentThread() final;
    5757
    5858private:
    59     class JSArrayBufferOwner : public WeakHandleOwner {
     59    class JSArrayBufferOwner final : public WeakHandleOwner {
    6060    public:
    61         bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, SlotVisitor&, const char** reason) override;
    62         void finalize(JSC::Handle<JSC::Unknown>, void* context) override;
     61        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, SlotVisitor&, const char** reason) final;
     62        void finalize(JSC::Handle<JSC::Unknown>, void* context) final;
    6363    };
    6464
  • trunk/Source/JavaScriptCore/runtime/Structure.h

    r261556 r261567  
    9797};
    9898
    99 class StructureFireDetail : public FireDetail {
     99class StructureFireDetail final : public FireDetail {
    100100public:
    101101    StructureFireDetail(const Structure* structure)
     
    104104    }
    105105   
    106     void dump(PrintStream& out) const override;
     106    void dump(PrintStream& out) const final;
    107107
    108108private:
     
    110110};
    111111
    112 class DeferredStructureTransitionWatchpointFire : public DeferredWatchpointFire {
     112class DeferredStructureTransitionWatchpointFire final : public DeferredWatchpointFire {
    113113    WTF_MAKE_NONCOPYABLE(DeferredStructureTransitionWatchpointFire);
    114114public:
    115115    JS_EXPORT_PRIVATE DeferredStructureTransitionWatchpointFire(VM&, Structure*);
    116     JS_EXPORT_PRIVATE ~DeferredStructureTransitionWatchpointFire();
    117    
    118     void dump(PrintStream& out) const override;
     116    JS_EXPORT_PRIVATE ~DeferredStructureTransitionWatchpointFire() final;
     117   
     118    void dump(PrintStream& out) const final;
    119119
    120120    const Structure* structure() const { return m_structure; }
  • trunk/Source/JavaScriptCore/runtime/WeakGCMap.h

    r261556 r261567  
    4141template<typename KeyArg, typename ValueArg, typename HashArg = typename DefaultHash<KeyArg>::Hash,
    4242    typename KeyTraitsArg = HashTraits<KeyArg>>
    43 class WeakGCMap : public WeakGCMapBase {
     43class WeakGCMap final : public WeakGCMapBase {
    4444    WTF_MAKE_FAST_ALLOCATED;
    4545    typedef Weak<ValueArg> ValueType;
     
    5353
    5454    explicit WeakGCMap(VM&);
    55     ~WeakGCMap();
     55    ~WeakGCMap() final;
    5656
    5757    ValueArg* get(const KeyType& key) const
     
    9292    inline bool contains(const KeyType& key) const;
    9393
    94     void pruneStaleEntries() override;
     94    void pruneStaleEntries() final;
    9595
    9696private:
  • trunk/Source/JavaScriptCore/wasm/WasmEntryPlan.h

    r261556 r261567  
    5151    JS_EXPORT_PRIVATE EntryPlan(Context*, Vector<uint8_t>&&, AsyncWork, CompletionTask&&);
    5252
    53     virtual ~EntryPlan() = default;
     53    ~EntryPlan() override = default;
    5454
    5555    void prepare();
Note: See TracChangeset for help on using the changeset viewer.