1590:             "needle": "^2.2.1",

1573:         "needle": {

2:   "name": "classification_pooling",

1: Needle

144: ### needle(method, url[, data][, options][, callback]) `(> 2.0.x)`

157: ### needle.head(url[, options][, callback])

170: ### needle.get(url[, options][, callback])

178: ### needle.post(url, data[, options][, callback])

190: ### needle.put(url, data[, options][, callback])

206: ### needle.patch(url, data[, options][, callback])

210: ### needle.delete(url, data[, options][, callback])

223: ### needle.request(method, url, data[, options][, callback])

4: [![NPM](https://nodei.co/npm/needle.png)](https://nodei.co/npm/needle/)

9: var needle = require('needle');

11: needle.get('http://www.google.com', function(error, response) {

17: Callbacks not floating your boat? Needle got your back.

25: // the callback is optional, and needle returns a `readableStream` object

27: needle

35: From version 2.0.x up, Promises are also supported. Just call `needle()` directly and you'll get a native Promise object.

38: needle('put', 'https://hacking.the.gibson/login', { password: 'god' }, { json: true })

47: With only two real dependencies, Needle supports:

61: This makes Needle an ideal alternative for performing quick HTTP requests in Node, either for API interaction, downlo...(144 bytes skipped)...

67: $ npm install needle

75: needle('get', 'https://server.com/posts/12')

84: needle.get('ifconfig.me/all.json', function(error, response, body) {

94: needle.get('https://google.com/images/logo.png').pipe(out).on('finish', function() {

99: As you can see, you can use Needle with Promises or without them. When using Promises or when a callback is passed, the response's bod...(179 bytes skipped)...

101: ...(19 bytes skipped)... passed, however, the buffering logic will be skipped but the response stream will still go through Needle's processing pipeline, so you get all the benefits of post-processing while keeping the streamishne...(25 bytes skipped)...

106: Depending on the response's Content-Type, Needle will either attempt to parse JSON or XML streams, or, if a text response was received, will ensure ...(41 bytes skipped)...

111: needle.get('http://stackoverflow.com/feeds', { compressed: true }, function(err, resp) {

126: var stream = needle.get('https://backend.server.com/everything.html', options);

146: Calling `needle()` directly returns a Promise. Besides `method` and `url`, all parameters are optional, although wh...(93 bytes skipped)...

149: needle('get', 'http://some.url.com')

155: Except from the above, all of Needle's request methods return a Readable stream, and both `options` and `callback` are optional. If pass...(126 bytes skipped)...

160: needle.head('https://my.backend.server.com', {

173: needle.get('google.com/search?q=syd+barrett', function(err, resp) {

174:   // if no http:// is found, Needle will automagically prepend it.

185: needle.post('https://my.app.com/endpoint', 'foo=bar', options, function(err, resp) {

201: needle.put('https://api.app.com/v2', nested, function(err, resp) {

218: needle.delete('https://api.app.com/messages/123', null, options, function(err, resp) {

233: needle.request('get', 'forum.com/search', params, function(err, resp) {

239: Now, if you set pass `json: true` among the options, Needle won't set your params as a querystring but instead send a JSON representation of your data through ...(97 bytes skipped)...

242: needle.request('get', 'forum.com/search', params, { json: true }, function(err, resp) {

250: The [Readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable) object returned by the above request methods emits the following events, in additi...(73 bytes skipped)...

256: Emitted when the underlying [http.ClientRequest](https://nodejs.org/api/http.html#http_class_http_clientrequest) emits a response event. This is after the connection is established and the hea...(146 bytes skipped)...

275: ...(74 bytes skipped)... data was consumed or an error ocurred somewhere in between. Unlike a regular stream's `end` event, Needle's `done` will be fired either on success or on failure, which is why the first argument may be an E...(28 bytes skipped)...

278: var resp = needle.get('something.worthy/of/being/streamed/by/needle');

291: Emitted when an error ocurrs. This should only happen once in the lifecycle of a Needle request.

302: ...(3 bytes skipped)... information about options that've changed, there's always [the changelog](https://github.com/tomas/needle/releases).

304:  - `agent`       : Uses an [http.Agent](https://nodejs.org/api/http.html#http_class_http_agent) of your choice, instead of the global, default one. Useful for tweaking the behaviour a...(80 bytes skipped)...

314: ...(182 bytes skipped)...p) errors on some servers that misbehave when receiving payloads of unknown size. Set it to `0` and Needle will get and set the stream's length for you, or leave unset for the default behaviour, which is no...(43 bytes skipped)...

321: ...(71 bytes skipped)...se bodies automagically. Defaults to `true`. You can also set this to 'xml' or 'json' in which case Needle will *only* parse the response if the content type matches.

336:  - `user_agent`: Sets the 'User-Agent' HTTP header. Defaults to `Needle/{version} (Node.js {node_version})`.

361:  - `follow_if_same_host`     : When true, Needle will only follow redirects that point to the same host as the original request. `false` by default....(0 bytes skipped)...

362:  - `follow_if_same_protocol` : When true, Needle will only follow redirects that point to the same protocol as the original request. `false` by defa...(4 bytes skipped)...

367: Yes sir, we have it. Needle includes a `defaults()` method, that lets you override some of the defaults for all future requests...(12 bytes skipped)...

370: needle.defaults({

376: This will override Needle's default user agent and 10-second timeout, and disable response parsing, so you don't need to pass...(38 bytes skipped)...

381: Since you can pass a custom HTTPAgent to Needle you can do all sorts of neat stuff. For example, if you want to use the [`tunnel`](https://github.c...(67 bytes skipped)...

389: needle.get('foobar.com', { agent: myAgent });

395: Unless you're running an old version of Node (< 0.11.4), by default Needle won't set the Connection header on requests, yielding Node's default behaviour of keeping the conne...(118 bytes skipped)...

397: ...(82 bytes skipped)...ime from exiting, either because of a bug or 'feature' that was changed on 0.11.4. To overcome this Needle does set the 'Connection' header to 'close' on those versions, however this also means that making ...(62 bytes skipped)...

407: needle.get('https://api.server.com', { username: 'you', password: 'secret' },

416: needle.get('https://username:password@api.server.com', function(err, resp) {

424: needle.get('other.server.com', { username: 'you', password: 'secret', auth: 'digest' },

426:     // needle prepends 'http://' to your URL, if missing

439: needle.get('api.github.com/users/tomas', options, function(err, resp, body) {

448: needle.get('https://news.ycombinator.com/rss', function(err, resp, body) {

456: needle.get('http://upload.server.com/tux.png', { output: '/tmp/tux.png' }, function(err, resp, body) {

464: needle.get('http://search.npmjs.org', { proxy: 'http://localhost:1234' }, function(err, resp, body) {

472: var stream = needle.get('http://www.as35662.net/100.log');

485: var stream = needle.get('http://jsonplaceholder.typicode.com/db', { parse: true });

504: needle.get('http://jsonplaceholder.typicode.com/db', { parse: true })

519: needle.post('http://my.other.app.com', data, { multipart: true }, function(err, resp, body) {

520:   // needle will read the file and include it in the form-data as binary

527: needle.put('https://api.app.com/v2', fs.createReadStream('myfile.txt'), function(err, resp, body) {

545: needle.post('http://somewhere.com/over/the/rainbow', data, { multipart: true }, function(err, resp, body) ...(1 bytes skipped)...

563: needle.post('http://test.com/', data, { timeout: 5000, multipart: true }, function(err, resp, body) {

582: > You can use Docker to run tests by creating a container and mounting the needle project directory on `/app`

583: > `docker create --name Needle -v /app -w /app -v /app/node_modules -i node:argon`

1127:             "needle": "^2.2.1",

208:         "class-utils": "^0.3.5",

643:         "posix-character-classes": "^0.1.0",

388:     "class-utils": {

390:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",

1108:         "needle": {

2138:     "posix-character-classes": {

2140:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",

1027: class Class : public Object {

502:   static ClassPtr class_class() { return class_class_; }

503:   static ClassPtr dynamic_class() { return dynamic_class_; }

504:   static ClassPtr void_class() { return void_class_; }

505:   static ClassPtr type_parameters_class() { return type_parameters_class_; }

506:   static ClassPtr type_arguments_class() { return type_arguments_class_; }

507:   static ClassPtr patch_class_class() { return patch_class_class_; }

508:   static ClassPtr function_class() { return function_class_; }

509:   static ClassPtr closure_data_class() { return closure_data_class_; }

510:   static ClassPtr ffi_trampoline_data_class() {

513:   static ClassPtr field_class() { return field_class_; }

514:   static ClassPtr script_class() { return script_class_; }

515:   static ClassPtr library_class() { return library_class_; }

516:   static ClassPtr namespace_class() { return namespace_class_; }

517:   static ClassPtr kernel_program_info_class() {

520:   static ClassPtr code_class() { return code_class_; }

521:   static ClassPtr instructions_class() { return instructions_class_; }

522:   static ClassPtr instructions_section_class() {

525:   static ClassPtr instructions_table_class() {

528:   static ClassPtr object_pool_class() { return object_pool_class_; }

529:   static ClassPtr pc_descriptors_class() { return pc_descriptors_class_; }

530:   static ClassPtr code_source_map_class() { return code_source_map_class_; }

531:   static ClassPtr compressed_stackmaps_class() {

534:   static ClassPtr var_descriptors_class() { return var_descriptors_class_; }

535:   static ClassPtr exception_handlers_class() {

538:   static ClassPtr context_class() { return context_class_; }

539:   static ClassPtr context_scope_class() { return context_scope_class_; }

540:   static ClassPtr sentinel_class() { return sentinel_class_; }

541:   static ClassPtr api_error_class() { return api_error_class_; }

542:   static ClassPtr language_error_class() { return language_error_class_; }

543:   static ClassPtr unhandled_exception_class() {

546:   static ClassPtr unwind_error_class() { return unwind_error_class_; }

547:   static ClassPtr singletargetcache_class() { return singletargetcache_class_; }

548:   static ClassPtr unlinkedcall_class() { return unlinkedcall_class_; }

549:   static ClassPtr monomorphicsmiablecall_class() {

552:   static ClassPtr icdata_class() { return icdata_class_; }

553:   static ClassPtr megamorphic_cache_class() { return megamorphic_cache_class_; }

554:   static ClassPtr subtypetestcache_class() { return subtypetestcache_class_; }

555:   static ClassPtr loadingunit_class() { return loadingunit_class_; }

556:   static ClassPtr weak_serialization_reference_class() {

559:   static ClassPtr weak_array_class() { return weak_array_class_; }

853:   static ClassPtr class_class_;

1586:   UntaggedClass::ClassLoadingState class_loading_state() const {

1601:   bool is_synthesized_class() const {

1607:   bool is_enum_class() const { return EnumBit::decode(state_bits()); }

1649:   bool is_mixin_class() const { return MixinClassBit::decode(state_bits()); }

1652:   bool is_base_class() const { return BaseClassBit::decode(state_bits()); }

1655:   bool is_interface_class() const {

2064:   ClassPtr patched_class() const { return untag()->patched_class(); }

2065:   ClassPtr origin_class() const { return untag()->origin_class(); }

4934:   ClassPtr toplevel_class() const { return untag()->toplevel_class(); }

9299:   virtual ClassPtr type_class() const {

1435:   bool IsNullClass() const { return id() == kNullCid; }

1438:   bool IsDynamicClass() const { return id() == kDynamicCid; }

1441:   bool IsVoidClass() const { return id() == kVoidCid; }

1444:   bool IsNeverClass() const { return id() == kNeverCid; }

1447:   bool IsObjectClass() const { return id() == kInstanceCid; }

1456:   bool IsFutureOrClass() const { return id() == kFutureOrCid; }

1459:   bool IsClosureClass() const { return id() == kClosureCid; }

1460:   static bool IsClosureClass(ClassPtr cls) {

1465:   bool IsRecordClass() const {

1934:   class ClassFinalizedBits : public BitField<uint32_t,

1938:   class ClassLoadingBits : public BitField<uint32_t,

2058:   kCurrentClass,  // Consider type params of current class only.

2062: class PatchClass : public Object {

4782: class ClassDictionaryIterator : public DictionaryIterator {

5281:   ArrayPtr classes_cache() const { return untag()->classes_cache(); }

7701:   intptr_t SizeFromClass() const {

8542:   virtual bool HasTypeClass() const { return type_class_id() != kIllegalCid; }

8855:   virtual bool HasTypeClass() const {

9014:   virtual bool HasTypeClass() const { return false; }

9290:   virtual bool HasTypeClass() const {

9365:   virtual bool HasTypeClass() const { return false; }

11112:   virtual bool HasTypeClass() const { return false; }

340: #define DEFINE_CLASS_TESTER(clazz)                                             \

854:   static ClassPtr dynamic_class_;

855:   static ClassPtr void_class_;

856:   static ClassPtr type_parameters_class_;

857:   static ClassPtr type_arguments_class_;

858:   static ClassPtr patch_class_class_;

859:   static ClassPtr function_class_;

860:   static ClassPtr closure_data_class_;

861:   static ClassPtr ffi_trampoline_data_class_;

862:   static ClassPtr field_class_;

863:   static ClassPtr script_class_;

864:   static ClassPtr library_class_;

865:   static ClassPtr namespace_class_;

866:   static ClassPtr kernel_program_info_class_;

867:   static ClassPtr code_class_;

868:   static ClassPtr instructions_class_;

869:   static ClassPtr instructions_section_class_;

870:   static ClassPtr instructions_table_class_;

871:   static ClassPtr object_pool_class_;

872:   static ClassPtr pc_descriptors_class_;

873:   static ClassPtr code_source_map_class_;

874:   static ClassPtr compressed_stackmaps_class_;

875:   static ClassPtr var_descriptors_class_;

876:   static ClassPtr exception_handlers_class_;

877:   static ClassPtr context_class_;

878:   static ClassPtr context_scope_class_;

879:   static ClassPtr sentinel_class_;

880:   static ClassPtr singletargetcache_class_;

881:   static ClassPtr unlinkedcall_class_;

882:   static ClassPtr monomorphicsmiablecall_class_;

883:   static ClassPtr icdata_class_;

884:   static ClassPtr megamorphic_cache_class_;

885:   static ClassPtr subtypetestcache_class_;

886:   static ClassPtr loadingunit_class_;

887:   static ClassPtr api_error_class_;

888:   static ClassPtr language_error_class_;

889:   static ClassPtr unhandled_exception_class_;

890:   static ClassPtr unwind_error_class_;

891:   static ClassPtr weak_serialization_reference_class_;

892:   static ClassPtr weak_array_class_;

2747:   bool include_class_name = true;

4804:   Class& toplevel_class_;

9016:   virtual classid_t type_class_id() const { return kIllegalCid; }

9296:   virtual classid_t type_class_id() const {

9366:   virtual classid_t type_class_id() const { return kIllegalCid; }

9377:   static intptr_t parameterized_class_id_offset() {

11114:   virtual classid_t type_class_id() const { return kIllegalCid; }

332:   intptr_t GetClassId() const {

595:   static const ClassId kClassId = kObjectCid;

1419:   GrowableObjectArrayPtr direct_subclasses() const {

1424:   GrowableObjectArrayPtr direct_subclasses_unsafe() const {

1475:   static intptr_t GetClassId(ClassPtr cls) {

1906:     kClassFinalizedPos = 2,

1907:     kClassFinalizedSize = 2,

1908:     kClassLoadingPos = kClassFinalizedPos + kClassFinalizedSize,  // = 4

1909:     kClassLoadingSize = 2,

1911:     kSynthesizedClassBit,

1921:     kMixinClassBit,

1922:     kBaseClassBit,

1923:     kInterfaceClassBit,

1943:   class SynthesizedClassBit

1954:   class MixinClassBit : public BitField<uint32_t, bool, kMixinClassBit, 1> {};

1955:   class BaseClassBit : public BitField<uint32_t, bool, kBaseClassBit, 1> {};

1956:   class InterfaceClassBit

2486:   ICDataPtr AsUnaryClassChecks() const { return AsUnaryClassChecksForArgNr(0); }

2763:   static NameFormattingParams DisambiguatedWithoutClassName(

6835:   classid_t OwnerClassId() const { return OwnerClassIdOf(ptr()); }

6836:   static classid_t OwnerClassIdOf(CodePtr raw) {

7318:     kClassIdIndex,

9370:   bool IsClassTypeParameter() const {

10220:   static const ClassId kClassId = kOneByteStringCid;

10344:   static const ClassId kClassId = kTwoByteStringCid;

10422:   static const ClassId kClassId = kExternalOneByteStringCid;

10511:   static const ClassId kClassId = kExternalTwoByteStringCid;

10813:   static const ClassId kClassId = kImmutableArrayCid;

11927:   static const ClassId kClassId = kConstMapCid;

12028:   static const ClassId kClassId = kConstSetCid;

13107: ObjectPtr MegamorphicCache::GetClassId(const Array& array, intptr_t index) {

45: class Assembler;

49: class Program;

50: class TreeNode;

53: #define DEFINE_FORWARD_DECLARATION(clazz) class clazz;

54: CLASS_LIST(DEFINE_FORWARD_DECLARATION)

56: class Api;

57: class ArgumentsDescriptor;

58: class Closure;

59: class Code;

60: class DeoptInstr;

61: class DisassemblyFormatter;

62: class FinalizablePersistentHandle;

63: class FlowGraphCompiler;

64: class HierarchyInfo;

65: class LocalScope;

66: class CallSiteResetter;

67: class CodeStatistics;

68: class IsolateGroupReloadContext;

69: class ObjectGraphCopier;

70: class NativeArguments;

72: #define REUSABLE_FORWARD_DECLARATION(name) class Reusable##name##HandleScope;

76: class Symbols;

77: class BaseTextBuffer;

86: // ContainsCompressedPointers() returns the same value for AllStatic class and

87: // class used for handles.

232:   friend class object##MessageSerializationCluster;                            \

233:   friend class object##MessageDeserializationCluster;

249:   friend class Object;

260:   friend class StackFrame;                                                     \

261:   friend class Thread;                                                         \

286:   friend class Object;                                                         \

287:   friend class StackFrame;                                                     \

288:   friend class Thread;                                                         \

306: class Object {

339: // Class testers.

351:   CLASS_LIST_FOR_HANDLES(DEFINE_CLASS_TESTER);

352: #undef DEFINE_CLASS_TESTER

450:   V(Class, null_class)                                                         \

511:     return ffi_trampoline_data_class_;

518:     return kernel_program_info_class_;

523:     return instructions_section_class_;

526:     return instructions_table_class_;

532:     return compressed_stackmaps_class_;

536:     return exception_handlers_class_;

544:     return unhandled_exception_class_;

550:     return monomorphicsmiablecall_class_;

557:     return weak_serialization_reference_class_;

585:   template <class FakeObject>

610:     //   core impl class name shown -> _OneByteString

639:   // class which has the same name as an already existing function, or

646:   enum class NameDisambiguation {

683:   // Explicit cast to silence -Wdynamic-class-memaccess.

804:   CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);

824:     // Indicates this class cannot be extended by dart code.

833:   static void RegisterClass(const Class& cls,

836:   static void RegisterPrivateClass(const Class& cls,

898:   friend void ClassTable::Register(const Class& cls);

900:   friend class Closure;

901:   friend class InstanceDeserializationCluster;

902:   friend class ObjectGraphCopier;  // For Object::InitializeObject

903:   friend class Simd128MessageDeserializationCluster;

904:   friend class OneByteString;

905:   friend class TwoByteString;

906:   friend class ExternalOneByteString;

907:   friend class ExternalTwoByteString;

908:   friend class Thread;

911:   friend class Reusable##name##HandleScope;

943: class PassiveObject : public Object {

991: // The first string in the triplet is a type name (usually a class).

996: enum class Nullability : uint8_t {

1004: enum class TypeEquality {

1012: enum class NNBDMode {

1020: enum class NNBDCompiledMode {

1135:   // If the interface of this class has a single concrete implementation, either

1142:   // propagated to this class's superclass and interfaces.

1143:   bool NoteImplementor(const Class& implementor) const;

1158:   // The mixin for this class if one exists. Otherwise, returns a raw pointer

1159:   // to this class.

1162:   // The NNBD mode of the library declaring this class.

1199:   // Return the Type with type parameters declared by this class filled in with

1205:   // class preceded by the type arguments declared for superclasses, etc.

1207:   // class B<T, S>

1208:   // class C<R> extends B<R, int>

1239:   // the super class.

1242:   // Return true if this class declares type parameters.

1255:   // If this class is parameterized, each instance has a type_arguments field.

1270:         compiler::target::Class::kNoTypeArguments) {

1271:       return compiler::target::Class::kNoTypeArguments;

1283:         target_value_in_bytes == RTN::Class::kNoTypeArguments) {

1285:              target_value_in_bytes == RTN::Class::kNoTypeArguments);

1287:       target_value = RTN::Class::kNoTypeArguments;

1312:   // The super type of this class, Object type if not explicitly specified.

1322:   // Asserts that the class of the super type has been resolved.

1323:   // If |class_table| is provided it will be used to resolve class id to the

1324:   // actual class object, instead of using current class table on the isolate

1326:   ClassPtr SuperClass(ClassTable* class_table = nullptr) const;

1338:   // type class. If [this] and [cls] are the same class, then the path is empty.

1347:                            const Class& cls,

1351:                            const Class& cls,

1360:   // class as [type]. If [this] is the type class of [type], then the path is

1365:   // class given type arguments for an instance of [this].

1367:   // Note: There may be multiple paths to [type]'s type class, but the result of

1380:   // If [this] is a subtype of a type with type class [cls], then this

1383:   // class type parameters corresponding to the type parameters of [this].

1387:   // If [this] is not a subtype of a type with type class [cls], returns null.

1388:   TypePtr GetInstantiationOf(Zone* zone, const Class& cls) const;

1391:   // where [cls] is the type class of [type], n is the number of type arguments

1393:   // free class type parameters corresponding to the type parameters of [this].

1397:   // If [this] is not a subtype of a type with type class [cls], returns null.

1401:   // Returns the list of classes directly implementing this class.

1414:   void AddDirectImplementor(const Class& subclass, bool is_mixin) const;

1418:   // Returns the list of classes having this class as direct superclass.

1431:   void AddDirectSubclass(const Class& subclass) const;

1434:   // Check if this class represents the class of null.

1437:   // Check if this class represents the 'dynamic' class.

1440:   // Check if this class represents the 'void' class.

1443:   // Check if this class represents the 'Never' class.

1446:   // Check if this class represents the 'Object' class.

1449:   // Check if this class represents the 'Function' class.

1452:   // Check if this class represents the 'Future' class.

1455:   // Check if this class represents the 'FutureOr' class.

1458:   // Check if this class represents the 'Closure' class.

1464:   // Check if this class represents the 'Record' class.

1482:   static bool IsSubtypeOf(const Class& cls,

1489:   // Check if this is the top level class.

1497:   // Returns an array of instance and static fields defined by this class.

1507:   intptr_t FindFieldIndex(const Field& needle) const;

1510:   // If this is a dart:internal.ClassID class, then inject our own const

1515:   // Returns an array of all instance fields of this class and its superclasses

1517:   // If |class_table| is provided it will be used to resolve super classes by

1518:   // class id, instead of the current class_table stored in the isolate.

1519:   ArrayPtr OffsetToFieldMap(ClassTable* class_table = nullptr) const;

1536:   intptr_t FindFunctionIndex(const Function& needle) const;

1538:   intptr_t FindImplicitClosureFunctionIndex(const Function& needle) const;

1576:   // Returns true if any class implements this interface via `implements`.

1578:   // instances of this class or its subclasses.

1591:     return class_loading_state() >= UntaggedClass::kDeclarationLoaded;

1597:     return class_loading_state() >= UntaggedClass::kTypeFinalized;

1604:   void set_is_synthesized_class() const;

1605:   void set_is_synthesized_class_unsafe() const;

1608:   void set_is_enum_class() const;

1635:   // Tests if this is a mixin application class which was desugared

1636:   // to a normal class by kernel mixin transformation

1650:   void set_is_mixin_class() const;

1653:   void set_is_base_class() const;

1658:   void set_is_interface_class() const;

1713:   intptr_t FindInvocationDispatcherFunctionIndex(const Function& needle) const;

1740:   // class and return the resulting value, or an error object if evaluating the

1750:   // Load class declaration (super type, interfaces, type parameters and

1757:   // Allocate a class used for VM internal objects.

1758:   template <class FakeObject, class TargetFakeObject>

1759:   static ClassPtr New(IsolateGroup* isolate_group, bool register_class = true);

1766:                       bool register_class = true);

1772:   static ClassPtr NewStringClass(intptr_t class_id,

1776:   static ClassPtr NewTypedDataClass(intptr_t class_id,

1780:   static ClassPtr NewTypedDataViewClass(intptr_t class_id,

1783:       intptr_t class_id,

1787:   static ClassPtr NewExternalTypedDataClass(intptr_t class_id,

1791:   static ClassPtr NewPointerClass(intptr_t class_id,

1796:   // TODO(srdjan): Also register kind of CHA optimization (e.g.: leaf class,

1800:   void DisableCHAOptimizedCode(const Class& subclass);

1806:   // Return the list of code objects that were compiled using CHA of this class.

1807:   // These code objects will be invalidated if new subclasses of this class

1817:                              const Class& old_cls) const;

1820:                                      const Class& new_cls) const;

1821:   void CopyCanonicalConstants(const Class& old_cls) const;

1822:   void CopyDeclarationType(const Class& old_cls) const;

1823:   void CheckReload(const Class& replacement,

1868:   void MarkFieldBoxedDuringReload(ClassTable* class_table,

1880:   // Caches the declaration type of this class.

1883:   bool CanReloadFinalized(const Class& replacement,

1885:   bool CanReloadPreFinalized(const Class& replacement,

1889:   bool RequiresInstanceMorphing(ClassTable* class_table,

1890:                                 const Class& replacement) const;

1892:   template <class FakeInstance, class TargetFakeInstance>

1925:     // Whether instances of the class cannot be sent across ports.

1928:     //    - class is marked with `@pramga('vm:isolate-unsendable')

1929:     //    - super class / super interface classes are marked as unsendable.

1932:   class ConstBit : public BitField<uint32_t, bool, kConstBit, 1> {};

1933:   class ImplementedBit : public BitField<uint32_t, bool, kImplementedBit, 1> {};

1942:   class AbstractBit : public BitField<uint32_t, bool, kAbstractBit, 1> {};

1945:   class FieldsMarkedNullableBit

1947:   class EnumBit : public BitField<uint32_t, bool, kEnumBit, 1> {};

1948:   class TransformedMixinApplicationBit

1950:   class IsAllocatedBit : public BitField<uint32_t, bool, kIsAllocatedBit, 1> {};

1951:   class IsLoadedBit : public BitField<uint32_t, bool, kIsLoadedBit, 1> {};

1952:   class HasPragmaBit : public BitField<uint32_t, bool, kHasPragmaBit, 1> {};

1953:   class SealedBit : public BitField<uint32_t, bool, kSealedBit, 1> {};

1958:   class FinalBit : public BitField<uint32_t, bool, kFinalBit, 1> {};

1959:   class IsIsolateUnsendableBit

2015:   // Calculates number of type arguments of this class.

2020:   // Assigns empty array to all raw class array fields.

2034:   // Allocate an instance class which has a VM implementation.

2035:   template <class FakeInstance, class TargetFakeInstance>

2038:                       bool register_class = true,

2041:   // Helper that calls 'Class::New<Instance>(kIllegalCid)'.

2044:   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);

2045:   friend class AbstractType;

2046:   friend class Instance;

2047:   friend class Object;

2048:   friend class Type;

2049:   friend class Intrinsifier;

2050:   friend class ProgramWalker;

2051:   friend class Precompiler;

2052:   friend class ClassFinalizer;

2057:   kAny,           // Consider type params of current class and functions.

2089:     return Class::IsInFullSnapshot(cls->untag()->patched_class());

2092:   static PatchClassPtr New(const Class& patched_class,

2093:                            const Class& origin_class);

2095:   static PatchClassPtr New(const Class& patched_class, const Script& source);

2098:   void set_patched_class(const Class& value) const;

2099:   void set_origin_class(const Class& value) const;

2105:   friend class Class;

2108: class SingleTargetCache : public Object {

2138:   friend class Class;

2141: class MonomorphicSmiableCall : public Object {

2162:   friend class Class;

2165: class CallSiteData : public Object {

2194:   friend class ICData;

2195:   friend class MegamorphicCache;

2198: class UnlinkedCall : public CallSiteData {

2214:   friend class ICData;  // For set_*() methods.

2219:   friend class Class;

2251: class ICData : public CallSiteData {

2421:   // Ensures there is a check for [class_ids].

2426:   void EnsureHasCheck(const GrowableArray<intptr_t>& class_ids,

2430:   // Adds one more class test to ICData. Length of 'classes' must be equal to

2432:   void AddCheck(const GrowableArray<intptr_t>& class_ids,

2438:   // Ensures there is a receiver check for [receiver_class_id].

2444:       intptr_t receiver_class_id,

2450:   // Adds sorted so that Smi is the first class-id. Use only for

2452:   void AddReceiverCheck(intptr_t receiver_class_id,

2461:                   GrowableArray<intptr_t>* class_ids,

2463:   void GetClassIdsAt(intptr_t index, GrowableArray<intptr_t>* class_ids) const;

2467:                           intptr_t* class_id,

2496:   bool HasReceiverClassId(intptr_t class_id) const;

2617:   void AddCheckInternal(const GrowableArray<intptr_t>& class_ids,

2620:   void AddReceiverCheckInternal(intptr_t receiver_class_id,

2659:   class NumArgsTestedBits : public BitField<uint32_t,

2663:   class TrackingExactnessBit : public BitField<uint32_t,

2667:   class DeoptReasonBits : public BitField<uint32_t,

2671:   class RebindRuleBits : public BitField<uint32_t,

2675:   class MegamorphicBit

2678:   class ReceiverCannotBeSmiBit : public BitField<uint32_t,

2711:   friend class CallSiteResetter;

2712:   friend class CallTargets;

2713:   friend class Class;

2714:   friend class VMDeserializationRoots;

2715:   friend class ICDataTestTask;

2716:   friend class VMSerializationRoots;

2743:   // By default function name includes the name of the enclosing class if any.

2744:   // However in some contexts this information is redundant and class name

2745:   // is already known. In this case setting |include_class_name| to false

2766:     params.include_class_name = false;

2773:     params.include_class_name = false;

2779: class Function : public Object {

2845:   // parameter of this function and R is a type parameter of class C, the owner

2851:   // parameter of this function and R is a type parameter of class C, the owner

2860:   // generic functions or class type parameters.

2876:   NNBDMode nnbd_mode() const { return Class::Handle(origin()).nnbd_mode(); }

3719:       const Class& klass = Class::Handle(Owner());

3728:       const Class& klass = Class::Handle(Owner());

3856:   class Name##Bit : public BitField<uint8_t, bool, k##Name##Pos, 1> {};

3885:   // static: Considered during class-side or top-level resolution rather than

3991:   class KindBits : public BitField<uint32_t,

3996:   class RecognizedBits : public BitField<uint32_t,

4000:   class ModifierBits : public BitField<uint32_t,

4006:   class name##Bit : public BitField<uint32_t, bool, k##name##Bit, 1> {};

4048:   friend class Class;

4049:   friend class Parser;  // For set_eval_script.

4052:   friend class UntaggedFunction;

4053:   friend class ClassFinalizer;  // To reset parent_function.

4054:   friend class Type;            // To adjust parent_function.

4055:   friend class Precompiler;     // To access closure data.

4056:   friend class ProgramVisitor;  // For set_parameter_types/names.

4059: class ClosureData : public Object {

4090:   friend class Class;

4091:   friend class Function;

4092:   friend class Precompiler;  // To wrap parent functions in WSRs.

4095: enum class EntryPointPragma {

4103: class FfiTrampolineData : public Object {

4130:   friend class Class;

4131:   friend class Function;

4134: class Field : public Object {

4237:   // Called during class finalization.

4261:   ClassPtr Origin() const;  // Either mixin class, or same as owner().

4268:   // Used by class finalizer, otherwise initialized in constructor.

4372:   // Return class id that any non-null value read from this field is guaranteed

4373:   // to have or kDynamicCid if such class id is not known.

4492:   // assumptions about guarded class id and nullability of this field.

4568:   friend class StoreFieldInstr;  // Generated code access to bit field.

4586:   class ConstBit : public BitField<uint16_t, bool, kConstBit, 1> {};

4587:   class StaticBit : public BitField<uint16_t, bool, kStaticBit, 1> {};

4588:   class FinalBit : public BitField<uint16_t, bool, kFinalBit, 1> {};

4589:   class HasNontrivialInitializerBit

4591:   class UnboxedBit : public BitField<uint16_t, bool, kUnboxedBit, 1> {};

4592:   class ReflectableBit : public BitField<uint16_t, bool, kReflectableBit, 1> {};

4593:   class InitializerChangedAfterInitializationBit

4598:   class HasPragmaBit : public BitField<uint16_t, bool, kHasPragmaBit, 1> {};

4599:   class CovariantBit : public BitField<uint16_t, bool, kCovariantBit, 1> {};

4600:   class GenericCovariantImplBit

4602:   class IsLateBit : public BitField<uint16_t, bool, kIsLateBit, 1> {};

4603:   class IsExtensionMemberBit

4605:   class NeedsLoadGuardBit

4607:   class HasInitializerBit

4641:   friend class Class;

4642:   friend class UntaggedField;

4643:   friend class FieldSerializationCluster;

4644:   friend class FieldDeserializationCluster;

4647: class Script : public Object {

4758:   friend class Class;

4759:   friend class Precompiler;

4762: class DictionaryIterator : public ValueObject {

4778:   friend class ClassDictionaryIterator;

4786:     // one top-level class per library left, not an array to iterate over.

4795:     return (next_ix_ < size_) || !toplevel_class_.IsNull();

4798:   // Returns a non-null raw class.

4809: class Library : public Object {

4872:   void AddClass(const Class& cls) const;

4907:   void AddAnonymousClass(const Class& cls) const;

4935:   void set_toplevel_class(const Class& value) const;

5110:   // Lookup class in the core lib which also contains various VM

5112:   static ClassPtr LookupCoreClass(const String& class_name);

5116:                                  const char* class_name,

5188:   friend class Bootstrap;

5189:   friend class Class;

5190:   friend class Debugger;

5191:   friend class DictionaryIterator;

5192:   friend class Isolate;

5193:   friend class LibraryDeserializationCluster;

5194:   friend class Namespace;

5195:   friend class Object;

5196:   friend class Precompiler;

5201: class Namespace : public Object {

5225:   friend class Class;

5226:   friend class Precompiler;

5229: class KernelProgramInfo : public Object {

5286:                        const Class& klass) const;

5292:   friend class Class;

5298: class ObjectPool : public Object {

5435:   friend class Class;

5436:   friend class Object;

5437:   friend class UntaggedObjectPool;

5440: class Instructions : public Object {

5449:   class SizeBits : public BitField<uint32_t, uint32_t, kSizePos, kSizeSize> {};

5450:   class FlagsBits : public BitField<uint32_t, bool, kFlagsPos, kFlagsSize> {};

5585:     // because there are no subclasses for the Instructions class, and the sizes

5625:   friend class Class;

5626:   friend class Code;

5627:   friend class AssemblyImageWriter;

5628:   friend class BlobImageWriter;

5629:   friend class ImageWriter;

5642: class InstructionsSection : public Object {

5663:   // There are no public instance methods for the InstructionsSection class, as

5664:   // all access to the contents is handled by methods on the Image class.

5672:   friend class Class;

5678: class InstructionsTable : public Object {

5742:   friend class Class;

5743:   friend class Deserializer;

5746: class LocalVarDescriptors : public Object {

5783:   friend class Class;

5784:   friend class Object;

5787: class PcDescriptors : public Object {

5820:   class Iterator : public ValueObject {

5876:     friend class PcDescriptors;

5921:   friend class Class;

5922:   friend class Object;

5925: class CodeSourceMap : public Object {

5969:   friend class Class;

5970:   friend class Object;

5973: class CompressedStackMaps : public Object {

6038:   class RawPayloadHandle {

6088:   class Iterator {

6256:     friend class StackMapEntry;

6270:   friend class Class;

6273: class ExceptionHandlers : public Object {

6332:   friend class Class;

6333:   friend class Object;

6357: class WeakSerializationReference : public Object {

6389:   friend class Class;

6392: class WeakArray : public Object {

6454:   friend class Class;

6455:   friend class Object;

6458: class Code : public Object {

6684:   enum class PoolAttachment {

6689:   class KindField : public BitField<intptr_t, CallKind, 0, 3> {};

6690:   class EntryPointField

6692:   class OffsetField

6718:   class Comments : public ZoneAllocated, public CodeComments {

6741:     friend class Code;

6820:   // a Function. It is up to the caller to guarantee it isn't a stub, class,

6971:   friend class UntaggedObject;  // For UntaggedObject::SizeFromClass().

6972:   friend class UntaggedCode;

6984:   class OptimizedBit : public BitField<int32_t, bool, kOptimizedBit, 1> {};

6988:   class ForceOptimizedBit

6991:   class AliveBit : public BitField<int32_t, bool, kAliveBit, 1> {};

6997:   class DiscardedBit : public BitField<int32_t, bool, kDiscardedBit, 1> {};

6999:   class PtrOffBits

7002:   class SlowFindRawCodeVisitor : public FindObjectVisitor {

7092:   friend class Class;

7093:   friend class CodeTestHelper;

7094:   friend class StubCode;     // for set_object_pool

7095:   friend class Precompiler;  // for set_object_pool

7096:   friend class FunctionSerializationCluster;

7097:   friend class CodeSerializationCluster;

7098:   friend class CodeDeserializationCluster;

7099:   friend class Deserializer;           // for InitializeCachedEntryPointsFrom

7100:   friend class StubCode;               // for set_object_pool

7101:   friend class MegamorphicCacheTable;  // for set_object_pool

7102:   friend class CodePatcher;            // for set_instructions

7103:   friend class ProgramVisitor;         // for set_instructions

7106:   friend class UntaggedFunction;

7107:   friend class CallSiteResetter;

7108:   friend class CodeKeyValueTrait;  // for UncheckedEntryPointOffset

7109:   friend class InstanceCall;       // for StorePointerUnaligned

7110:   friend class StaticCall;         // for StorePointerUnaligned

7113: class Context : public Object {

7177:   friend class Class;

7178:   friend class Object;

7181: // The ContextScope class makes it possible to delay the compilation of a local

7191: class ContextScope : public Object {

7282:   friend class Class;

7283:   friend class Object;

7286: // Class of special sentinel values:

7297: class Sentinel : public Object {

7307:   friend class Class;

7308:   friend class Object;

7311: class MegamorphicCache : public CallSiteData {

7345:   void EnsureContains(const Smi& class_id, const Object& target) const;

7346:   ObjectPtr Lookup(const Smi& class_id) const;

7353:   friend class Class;

7354:   friend class MegamorphicCacheTable;

7355:   friend class ProgramVisitor;

7360:   void InsertLocked(const Smi& class_id, const Object& target) const;

7362:   ObjectPtr LookupLocked(const Smi& class_id) const;

7364:   void InsertEntryLocked(const Smi& class_id, const Object& target) const;

7368:                               const Smi& class_id,

7377: class SubtypeTestCache : public Object {

7392:   void AddCheck(const Object& instance_class_id_or_signature,

7401:                 Object* instance_class_id_or_signature,

7413:                        Object* instance_class_id_or_signature,

7428:   bool HasCheck(const Object& instance_class_id_or_signature,

7483:   friend class Class;

7484:   friend class VMSerializationRoots;

7485:   friend class VMDeserializationRoots;

7488: class LoadingUnit : public Object {

7531:   friend class Class;

7534: class Error : public Object {

7542: class ApiError : public Error {

7560:   friend class Class;

7563: class LanguageError : public Error {

7626:   friend class Class;

7629: class UnhandledException : public Error {

7658:   friend class Class;

7659:   friend class ObjectStore;

7662: class UnwindError : public Error {

7682:   friend class Class;

7685: // Instance is the base class for all instance objects (aka the Object class

7687: class Instance : public Object {

7703:     const Class& cls = Class::Handle(clazz());

7777:   // class implementing a 'call' method, return true and set the function

7800:       const Class& method_cls,

7816:   static InstancePtr New(const Class& cls, Heap::Space space = Heap::kNew);

7817:   static InstancePtr NewAlreadyFinalized(const Class& cls,

7826:   // only the class_id is different. So, it is safe to use subtype instances in

7877:   // They are needed due to the extraction of the class in IsValidFieldOffset.

7904:   friend class ByteBuffer;

7905:   friend class Class;

7906:   friend class Closure;

7907:   friend class Pointer;

7908:   friend class DeferredObject;

7909:   friend class FlowGraphSerializer;

7910:   friend class FlowGraphDeserializer;

7911:   friend class RegExp;

7912:   friend class StubCode;

7913:   friend class TypedDataView;

7914:   friend class InstanceSerializationCluster;

7915:   friend class InstanceDeserializationCluster;

7916:   friend class ClassDeserializationCluster;  // vtable

7917:   friend class InstanceMorpher;

7918:   friend class Obfuscator;  // RawGetFieldAtOffset, RawSetFieldAtOffset

7921: class LibraryPrefix : public Instance {

7956:   friend class Class;

7961: class TypeParameters : public Object {

8007:              bool are_class_type_parameters,

8035:   friend class Class;

8036:   friend class ClassFinalizer;

8037:   friend class FlowGraphSerializer;

8038:   friend class FlowGraphDeserializer;

8039:   friend class Function;

8040:   friend class FunctionType;

8041:   friend class Object;

8042:   friend class Precompiler;

8046: class TypeArguments : public Instance {

8126:   // a raw (null) function type arguments, i.e. consider each class type

8193:       const Class& instantiator_class,

8210:   // Add the class name and URI of each type argument of this vector to the uris

8217:   // type from the various type argument vectors (class instantiator, function,

8241:   class Cache : public ValueObject {

8427:     friend class TypeArguments;  // For asserts against data_.

8477:   // If raw_instantiated is true, consider each class type parameter to be first

8491:   friend class AbstractType;

8492:   friend class Class;

8493:   friend class ClearTypeHashVisitor;

8494:   friend class Object;

8499: class AbstractType : public Instance {

8543:   virtual classid_t type_class_id() const;

8544:   virtual ClassPtr type_class() const;

8567:   // instantiation. Consider a class C<T> declaring a non-generic method

8569:   // generic function bar<B> as argument and its function type refers to class

8658:   // Add the class name and URI of each occurring type to the uris

8664:   // The name of this type's class, i.e. without the type argument names of this

8672:   bool IsDynamicType() const { return type_class_id() == kDynamicCid; }

8675:   bool IsVoidType() const { return type_class_id() == kVoidCid; }

8687:   bool IsObjectType() const { return type_class_id() == kInstanceCid; }

8703:   bool IsBoolType() const { return type_class_id() == kBoolCid; }

8724:   bool IsNumberType() const { return type_class_id() == kNumberCid; }

8727:   bool IsSmiType() const { return type_class_id() == kSmiCid; }

8730:   bool IsMintType() const { return type_class_id() == kMintCid; }

8748:   bool IsFutureOrType() const { return type_class_id() == kFutureOrCid; }

8763:   // Returns true if this type has a type class permitted by SendPort.send for

8812:   // NextFieldOffset() are required to register class _AbstractType.

8841:   friend class Class;

8842:   friend class Function;

8843:   friend class TypeArguments;

8844:   friend class TypeRef;

8847: // A Type consists of a class, possibly parameterized with type

8849: class Type : public AbstractType {

8856:     ASSERT(type_class_id() != kIllegalCid);

8860:   virtual classid_t type_class_id() const;

8861:   virtual ClassPtr type_class() const;

8862:   void set_type_class(const Class& value) const;

8876:   // canonicalization (passed-in cls must match type_class()).

8877:   bool IsDeclarationTypeOf(const Class& cls) const;

8969:   // The finalized type of the given non-parameterized class.

8970:   static TypePtr NewNonParameterizedType(const Class& type_class);

8972:   static TypePtr New(const Class& clazz,

8983:   void set_type_class_id(intptr_t id) const;

8988:   friend class Class;

8989:   friend class TypeArguments;

8990:   friend class ClearTypeHashVisitor;

8996: class FunctionType : public AbstractType {

9277:   friend class Class;

9278:   friend class ClearTypeHashVisitor;

9279:   friend class Function;

9286: class TypeRef : public AbstractType {

9297:     return AbstractType::Handle(type()).type_class_id();

9300:     return AbstractType::Handle(type()).type_class();

9349:   friend class Class;

9352: // A TypeParameter represents a type parameter of a parameterized class.

9356: // the class HashMap<K, V>. At compile time, the TypeParameter is not

9359: // as type argument (rather than type parameter) of the parameterized class.

9362: class TypeParameter : public AbstractType {

9367:   classid_t parameterized_class_id() const;

9368:   void set_parameterized_class_id(classid_t value) const;

9369:   ClassPtr parameterized_class() const;

9371:     return parameterized_class_id() != kFunctionCid;

9374:     return parameterized_class_id() == kFunctionCid;

9378:     return OFFSET_OF(UntaggedTypeParameter, parameterized_class_id_);

9445:   static const char* CanonicalNameCString(bool is_class_type_parameter,

9453:   // 'parameterized_class' is null for a function type parameter.

9454:   static TypeParameterPtr New(const Class& parameterized_class,

9464:   void set_parameterized_class(const Class& value) const;

9470:   friend class Class;

9471:   friend class ClearTypeHashVisitor;

9474: class Number : public Instance {

9482:   friend class Class;

9485: class Integer : public Number {

9557:   friend class Class;

9560: class Smi : public Integer {

9589:   static ClassPtr Class();

9615:     // Indicates this class cannot be extended by dart code.

9622:   friend class Api;  // For ValueFromRaw

9623:   friend class Class;

9624:   friend class Object;

9625:   friend class ReusableSmiHandleScope;

9626:   friend class Thread;

9629: class SmiTraits : AllStatic {

9641: class Mint : public Integer {

9672:   friend class Integer;

9673:   friend class MintMessageDeserializationCluster;

9683:   friend class Class;

9684:   friend class Number;

9687: // Class Double represents class Double in corelib_impl, which implements

9688: // abstract class double in corelib.

9689: class Double : public Number {

9721:   friend class Class;

9722:   friend class Number;

9726: class Symbol : public AllStatic {

9728:   static bool IsSymbolCid(Thread* thread, classid_t class_id);

9734: class String : public Instance {

9756:   class CodePointIterator : public ValueObject {

10080:   friend class Class;

10081:   friend class Symbols;

10082:   friend class StringSlice;  // SetHash

10084:   friend class CharArray;     // SetHash

10085:   friend class ConcatString;  // SetHash

10086:   friend class OneByteString;

10087:   friend class TwoByteString;

10088:   friend class ExternalOneByteString;

10089:   friend class ExternalTwoByteString;

10090:   friend class UntaggedOneByteString;

10091:   friend class RODataSerializationCluster;  // SetHash

10092:   friend class Pass2Visitor;                // Stack "handle"

10096: class StringHasher : public ValueObject {

10121: class OneByteString : public AllStatic {

10246:   friend class Class;

10247:   friend class ExternalOneByteString;

10248:   friend class FlowGraphSerializer;

10249:   friend class ImageWriter;

10250:   friend class String;

10251:   friend class StringHasher;

10252:   friend class Symbols;

10253:   friend class Utf8;

10254:   friend class OneByteStringMessageSerializationCluster;

10255:   friend class Deserializer;

10256:   friend class JSONWriter;

10259: class TwoByteString : public AllStatic {

10368:   friend class Class;

10369:   friend class FlowGraphSerializer;

10370:   friend class ImageWriter;

10371:   friend class String;

10372:   friend class StringHasher;

10373:   friend class Symbols;

10374:   friend class TwoByteStringMessageSerializationCluster;

10375:   friend class JSONWriter;

10378: class ExternalOneByteString : public AllStatic {

10459:     // Indicates this class cannot be extended by dart code.

10463:   friend class Class;

10464:   friend class String;

10465:   friend class StringHasher;

10466:   friend class Symbols;

10467:   friend class Utf8;

10468:   friend class JSONWriter;

10471: class ExternalTwoByteString : public AllStatic {

10548:     // Indicates this class cannot be extended by dart code.

10552:   friend class Class;

10553:   friend class String;

10554:   friend class StringHasher;

10555:   friend class Symbols;

10556:   friend class JSONWriter;

10564: // Class Bool implements Dart core class bool.

10565: class Bool : public Instance {

10587:   friend class Class;

10588:   friend class Object;  // To initialize the true and false values.

10591: class Array : public Instance {

10724:   // Make the array immutable to Dart code by switching the class pointer

10771:   static ArrayPtr New(intptr_t class_id,

10774:   static ArrayPtr NewUninitialized(intptr_t class_id,

10798:   friend class Class;

10799:   friend class ImmutableArray;

10800:   friend class Object;

10801:   friend class String;

10802:   friend class MessageDeserializer;

10805: class ImmutableArray : public AllStatic {

10823:     // Indicates this class cannot be extended by dart code.

10831:   friend class Class;

10834: class GrowableObjectArray : public Instance {

10935:   friend class Array;

10936:   friend class Class;

10939: class Float32x4 : public Instance {

10972:   friend class Class;

10975: class Int32x4 : public Instance {

11005:   friend class Class;

11008: class Float64x2 : public Instance {

11035:   friend class Class;

11039: class RecordShape {

11109: class RecordType : public AbstractType {

11185:   friend class Class;

11186:   friend class ClassFinalizer;

11187:   friend class ClearTypeHashVisitor;

11188:   friend class Record;

11191: class Record : public Instance {

11267:   friend class Class;

11268:   friend class Object;

11271: class PointerBase : public Instance {

11278: class TypedDataBase : public PointerBase {

11378:   friend class Class;

11393: class TypedData : public TypedDataBase {

11443:   static intptr_t MaxElements(intptr_t class_id) {

11444:     ASSERT(IsTypedDataClassId(class_id));

11445:     return (kSmiMax / ElementSizeInBytes(class_id));

11448:   static intptr_t MaxNewSpaceElements(intptr_t class_id) {

11449:     ASSERT(IsTypedDataClassId(class_id));

11451:            ElementSizeInBytes(class_id);

11454:   static TypedDataPtr New(intptr_t class_id,

11476:   // Therefore this method is private and the call-sites in this class need to

11484:   friend class Class;

11485:   friend class ExternalTypedData;

11486:   friend class TypedDataView;

11489: class ExternalTypedData : public TypedDataBase {

11503:   static intptr_t MaxElements(intptr_t class_id) {

11504:     ASSERT(IsExternalTypedDataClassId(class_id));

11505:     return (kSmiMax / ElementSizeInBytes(class_id));

11509:       intptr_t class_id,

11539:   friend class Class;

11542: class TypedDataView : public TypedDataBase {

11544:   static TypedDataViewPtr New(intptr_t class_id,

11546:   static TypedDataViewPtr New(intptr_t class_id,

11610:   friend class Class;

11611:   friend class Object;

11612:   friend class TypedDataViewDeserializationCluster;

11615: class ByteBuffer : public AllStatic {

11641: class Pointer : public Instance {

11675:   friend class Class;

11678: class DynamicLibrary : public Instance {

11704:   friend class Class;

11707: class LinkedHashBase : public Instance {

11827:   friend class Class;

11828:   friend class ImmutableLinkedHashBase;

11829:   friend class LinkedHashBaseDeserializationCluster;

11832: class ImmutableLinkedHashBase : public AllStatic {

11846: class Map : public LinkedHashBase {

11853:   static MapPtr NewDefault(intptr_t class_id = kMapCid,

11855:   static MapPtr New(intptr_t class_id,

11868:   class Iterator : public ValueObject {

11906:   static MapPtr NewUninitialized(intptr_t class_id,

11909:   friend class Class;

11910:   friend class ConstMap;

11911:   friend class MapDeserializationCluster;

11917: class ConstMap : public AllStatic {

11933:     // Indicates this class cannot be extended by dart code.

11941:   friend class Class;

11949: class Set : public LinkedHashBase {

11956:   static SetPtr NewDefault(intptr_t class_id = kSetCid,

11958:   static SetPtr New(intptr_t class_id,

11971:   class Iterator : public ValueObject {

12007:   static SetPtr NewUninitialized(intptr_t class_id,

12010:   friend class Class;

12011:   friend class ConstSet;

12012:   friend class SetDeserializationCluster;

12018: class ConstSet : public AllStatic {

12034:     // Indicates this class cannot be extended by dart code.

12042:   friend class Class;

12045: class Closure : public Instance {

12142:   friend class Class;

12146: class Capability : public Instance {

12157:   friend class Class;

12161: class ReceivePort : public Instance {

12195:   friend class Class;

12199: class SendPort : public Instance {

12219:   friend class Class;

12224: class TransferableTypedDataPeer {

12251: class TransferableTypedData : public Instance {

12261:   friend class Class;

12264: class DebuggerStackTrace;

12267: class StackTrace : public Instance {

12321:   friend class Class;

12322:   friend class DebuggerStackTrace;

12325: class SuspendState : public Instance {

12414:   friend class Class;

12417: class RegExpFlags {

12471: class RegExp : public Instance {

12490:   class TypeBits : public BitField<int8_t, RegExType, kTypePos, kTypeSize> {};

12491:   class GlobalBit : public BitField<int8_t, bool, kFlagsPos, 1> {};

12492:   class IgnoreCaseBit : public BitField<int8_t, bool, GlobalBit::kNextBit, 1> {

12494:   class MultiLineBit

12496:   class UnicodeBit : public BitField<int8_t, bool, MultiLineBit::kNextBit, 1> {

12498:   class DotAllBit : public BitField<int8_t, bool, UnicodeBit::kNextBit, 1> {};

12500:   class FlagsBits : public BitField<int8_t, int8_t, kFlagsPos, kFlagsSize> {};

12645:   friend class Class;

12649: class WeakProperty : public Instance {

12677:   friend class Class;

12681: class WeakReference : public Instance {

12703:   friend class Class;

12706: class FinalizerBase;

12707: class FinalizerEntry : public Instance {

12771:   friend class Class;

12774: class FinalizerBase : public Instance {

12806:   friend class Class;

12809: class Finalizer : public FinalizerBase {

12828:   friend class Class;

12831: class NativeFinalizer : public FinalizerBase {

12854:   friend class Class;

12857: class MirrorReference : public Instance {

12888:   friend class Class;

12891: class UserTag : public Instance {

12933:   friend class Class;

12936: // Represents abstract FutureOr class in dart:async.

12937: class FutureOr : public Instance {

12953:   friend class Class;

12960:     return Smi::Class();

12962:   return IsolateGroup::Current()->class_table()->At(ptr()->GetClassId());

13100:                                 const Smi& class_id,

13103:   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);

13217: // This helper class can then be used via

13252: class ArrayOfTuplesView {

13256:   class Iterator;

13258:   class TupleView {

13284:     friend class Iterator;

13287:   class Iterator {

85: // For AllStatic classes like OneByteString. Checks that

186:   static const ClassId kClassId = k##object##Cid;                              \

336:   inline ClassPtr clazz() const;

599:     // Internal names are the true names of classes, fields,

603:     // The names of core implementation classes (like _OneByteString)

608:     //   private constructor        -> _MyClass@6b3832b.

609:     //   private named constructor  -> _MyClass@6b3832b.named

619:     //   _MyClass@6b3832b.      -> _MyClass

620:     //   _MyClass@6b3832b.named -> _MyClass.named

626:     // the names of core implementation classes are remapped to their

631:     //   _MyClass@6b3832b.      -> _MyClass

632:     //   _MyClass@6b3832b.named -> _MyClass.named

1050:   static intptr_t host_instance_size(ClassPtr clazz) {

1053:   static intptr_t target_instance_size(ClassPtr clazz) {

1125:     return UntaggedObject::ClassIdTag::is_valid(value);

1129:     ASSERT(value >= 0 && value < std::numeric_limits<classid_t>::max());

1132:   static intptr_t id_offset() { return OFFSET_OF(UntaggedClass, id_); }

1147:     return OFFSET_OF(UntaggedClass, num_type_arguments_);

1160:   ClassPtr Mixin() const;

1201:   // in superclass clauses.

1215:     return OFFSET_OF(UntaggedClass, declaration_type_);

1309:     return OFFSET_OF(UntaggedClass, host_type_arguments_field_offset_in_words_);

1319:     return OFFSET_OF(UntaggedClass, super_type_);

1349:                            bool consider_only_super_classes = false) const;

1352:                            bool consider_only_super_classes = false) const {

1354:                                consider_only_super_classes);

1372:                            bool consider_only_super_classes = false) const;

1375:                            bool consider_only_super_classes = false) const {

1377:                                consider_only_super_classes);

1450:   bool IsDartFunctionClass() const;

1453:   bool IsFutureClass() const;

1469:   static bool IsInFullSnapshot(ClassPtr cls) {

1573:     return RoundedAllocationSize(sizeof(UntaggedClass));

1587:     return ClassLoadingBits::decode(state_bits());

1611:     return ClassFinalizedBits::decode(state_bits()) ==

1612:                UntaggedClass::kFinalized ||

1613:            ClassFinalizedBits::decode(state_bits()) ==

1614:                UntaggedClass::kAllocateFinalized;

1620:     return ClassFinalizedBits::decode(state_bits()) ==

1621:            UntaggedClass::kAllocateFinalized;

1626:     return ClassFinalizedBits::decode(state_bits()) ==

1627:            UntaggedClass::kPreFinalized;

1679:   static uint16_t NumNativeFieldsOf(ClassPtr clazz) {

1682:   static bool IsIsolateUnsendable(ClassPtr clazz) {

1761:   // Allocate instance classes.

1762:   static ClassPtr New(const Library& lib,

1767:   static ClassPtr NewNativeWrapper(const Library& library,

1771:   // Allocate the raw string classes.

1775:   // Allocate the raw TypedData classes.

1779:   // Allocate the raw TypedDataView/ByteDataView classes.

1782:   static ClassPtr NewUnmodifiableTypedDataViewClass(