| /third_party/python/Lib/ |
| D | _py_abc.py | 36 cls = super().__new__(mcls, name, bases, namespace, **kwargs)
43 value = getattr(cls, name, None)
46 cls.__abstractmethods__ = frozenset(abstracts)
48 cls._abc_registry = WeakSet()
49 cls._abc_cache = WeakSet()
50 cls._abc_negative_cache = WeakSet()
51 cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
52 return cls
54 def register(cls, subclass): argument
61 if issubclass(subclass, cls):
[all …]
|
| D | enum.py | 58 def _make_class_unpicklable(cls): argument
64 cls.__reduce_ex__ = _break_on_call_reduce
65 cls.__module__ = '<unknown>'
166 def __prepare__(metacls, cls, bases, **kwds): argument
168 metacls._check_for_existing_members(cls, bases)
171 enum_dict._cls_name = cls
173 member_type, first_enum = metacls._get_mixins_(cls, bases)
180 def __new__(metacls, cls, bases, classdict, **kwds): argument
191 member_type, first_enum = metacls._get_mixins_(cls, bases)
215 enum_class = super().__new__(metacls, cls, bases, classdict, **kwds)
[all …]
|
| D | abc.py | 106 cls = super().__new__(mcls, name, bases, namespace, **kwargs)
107 _abc_init(cls)
108 return cls
110 def register(cls, subclass): argument
115 return _abc_register(cls, subclass)
117 def __instancecheck__(cls, instance): argument
119 return _abc_instancecheck(cls, instance)
121 def __subclasscheck__(cls, subclass): argument
123 return _abc_subclasscheck(cls, subclass)
125 def _dump_registry(cls, file=None): argument
[all …]
|
| D | dataclasses.py | 239 def __class_getitem__(cls, type): argument
599 def _frozen_get_del_attr(cls, fields, globals): argument
600 locals = {'cls': cls,
664 def _is_type(annotation, cls, a_module, a_type, is_type_predicate): argument
712 ns = sys.modules.get(cls.__module__).__dict__
715 module = sys.modules.get(cls.__module__)
723 def _get_field(cls, a_name, a_type, default_kw_only): argument
731 default = getattr(cls, a_name, MISSING)
767 and _is_type(f.type, cls, typing, typing.ClassVar,
779 and _is_type(f.type, cls, dataclasses, dataclasses.InitVar,
[all …]
|
| /third_party/FreeBSD/sys/kern/ |
| D | subr_kobj.c | 80 kobj_class_compile_common(kobj_class_t cls, kobj_ops_t ops) in kobj_class_compile_common() argument
88 if (cls->ops) in kobj_class_compile_common()
94 for (i = 0, m = cls->methods; m->desc; i++, m++) { in kobj_class_compile_common()
104 ops->cls = cls; in kobj_class_compile_common()
105 cls->ops = ops; in kobj_class_compile_common()
109 kobj_class_compile(kobj_class_t cls) in kobj_class_compile() argument
129 if (cls->ops) { in kobj_class_compile()
135 kobj_class_compile_common(cls, ops); in kobj_class_compile()
140 kobj_class_compile_static(kobj_class_t cls, kobj_ops_t ops) in kobj_class_compile_static() argument
149 cls->refs++; in kobj_class_compile_static()
[all …]
|
| /third_party/python/Lib/idlelib/idle_test/ |
| D | test_editor.py | 16 def setUpClass(cls): argument
18 cls.root = Tk()
19 cls.root.withdraw()
22 def tearDownClass(cls): argument
23 cls.root.update_idletasks()
24 for id in cls.root.tk.call('after', 'info'):
25 cls.root.after_cancel(id)
26 cls.root.destroy()
27 del cls.root
105 def setUpClass(cls): argument
[all …]
|
| D | test_help_about.py | 25 def setUpClass(cls): argument
27 cls.root = Tk()
28 cls.root.withdraw()
29 cls.dialog = About(cls.root, 'About IDLE', _utest=True)
32 def tearDownClass(cls): argument
33 del cls.dialog
34 cls.root.update_idletasks()
35 cls.root.destroy()
36 del cls.root
93 def setUpClass(cls): argument
[all …]
|
| D | test_config_key.py | 32 def setUpClass(cls): argument
34 cls.root = Tk()
35 cls.root.withdraw()
37 cls.dialog = cls.Validator(
38 cls.root, 'Title', '<<Test>>', keylist, _utest=True)
41 def tearDownClass(cls): argument
42 cls.dialog.cancel()
43 cls.root.update_idletasks()
44 cls.root.destroy()
45 del cls.dialog, cls.root
[all …]
|
| D | test_iomenu.py | 13 def setUpClass(cls): argument
15 cls.root = Tk()
16 cls.root.withdraw()
17 cls.editwin = EditorWindow(root=cls.root)
18 cls.io = iomenu.IOBinding(cls.editwin)
21 def tearDownClass(cls): argument
22 cls.io.close()
23 cls.editwin._close()
24 del cls.editwin
25 cls.root.update_idletasks()
[all …]
|
| D | test_format.py | 54 def setUpClass(cls): argument
56 cls.text = Text()
272 def setUpClass(cls): argument
274 cls.root = Tk()
275 cls.root.withdraw()
276 editor = Editor(root=cls.root)
277 cls.text = editor.text.text # Test code does not need the wrapper.
278 cls.formatter = ft.FormatParagraph(editor).format_paragraph_event
282 def tearDownClass(cls): argument
283 del cls.text, cls.formatter
[all …]
|
| D | test_autocomplete_w.py | 13 def setUpClass(cls): argument
15 cls.root = Tk()
16 cls.root.withdraw()
17 cls.text = Text(cls.root)
18 cls.acw = acw.AutoCompleteWindow(cls.text, tags=None)
21 def tearDownClass(cls): argument
22 del cls.text, cls.acw
23 cls.root.update_idletasks()
24 cls.root.destroy()
25 del cls.root
|
| D | test_calltip_w.py | 12 def setUpClass(cls): argument
14 cls.root = Tk()
15 cls.root.withdraw()
16 cls.text = Text(cls.root)
17 cls.calltip = calltip_w.CalltipWindow(cls.text)
20 def tearDownClass(cls): argument
21 cls.root.update_idletasks()
22 cls.root.destroy()
23 del cls.text, cls.root
|
| /third_party/typescript/tests/baselines/reference/ |
| D | abstractClassUnionInstantiation.types | 50 [ConcreteA, AbstractA, AbstractB].map(cls => new cls()); // should error
51 >[ConcreteA, AbstractA, AbstractB].map(cls => new cls()) : any[]
58 >cls => new cls() : (cls: typeof ConcreteA | typeof AbstractA | typeof AbstractB) => any
59 >cls : typeof ConcreteA | typeof AbstractA | typeof AbstractB
60 >new cls() : any
61 >cls : typeof ConcreteA | typeof AbstractA | typeof AbstractB
63 [AbstractA, AbstractB, ConcreteA].map(cls => new cls()); // should error
64 >[AbstractA, AbstractB, ConcreteA].map(cls => new cls()) : any[]
71 >cls => new cls() : (cls: typeof ConcreteA | typeof AbstractA | typeof AbstractB) => any
72 >cls : typeof ConcreteA | typeof AbstractA | typeof AbstractB
[all …]
|
| D | abstractClassUnionInstantiation.js | 19 [ConcreteA, AbstractA, AbstractB].map(cls => new cls()); // should error
20 [AbstractA, AbstractB, ConcreteA].map(cls => new cls()); // should error
21 [ConcreteA, ConcreteB].map(cls => new cls()); // should work
22 [AbstractA, AbstractB].map(cls => new cls()); // should error
48 [ConcreteA, AbstractA, AbstractB].map(function (cls) { return new cls(); }); // should error argument
49 [AbstractA, AbstractB, ConcreteA].map(function (cls) { return new cls(); }); // should error argument
50 [ConcreteA, ConcreteB].map(function (cls) { return new cls(); }); // should work argument
51 [AbstractA, AbstractB].map(function (cls) { return new cls(); }); // should error argument
|
| D | jsDeclarationsExportSubAssignments.symbols | 1 === tests/cases/conformance/jsdoc/declarations/cls.js ===
3 >Strings : Symbol(Strings, Decl(cls.js, 0, 5))
6 >a : Symbol(a, Decl(cls.js, 0, 17))
9 >b : Symbol(b, Decl(cls.js, 1, 11))
13 >Foo : Symbol(Foo, Decl(cls.js, 3, 2))
16 >module.exports : Symbol(module.exports, Decl(cls.js, 0, 0))
17 >module : Symbol(export=, Decl(cls.js, 4, 12))
18 >exports : Symbol(export=, Decl(cls.js, 4, 12))
19 >Foo : Symbol(Foo, Decl(cls.js, 3, 2))
22 >module.exports.Strings : Symbol(Strings, Decl(cls.js, 5, 21))
[all …]
|
| D | jsDeclarationsExportForms.types | 1 === tests/cases/conformance/jsdoc/declarations/cls.js ===
11 export * from "./cls";
16 export * from "./cls";
19 import {Foo} from "./cls";
26 import * as ns from "./cls";
33 import * as ns from "./cls";
40 import * as ns from "./cls";
48 const ns = require("./cls");
50 >require("./cls") : typeof ns
52 >"./cls" : "./cls"
[all …]
|
| D | jsDeclarationsClassExtendsVisibility.symbols | 1 === tests/cases/conformance/jsdoc/declarations/cls.js ===
3 >Bar : Symbol(Bar, Decl(cls.js, 0, 5))
8 >Strings : Symbol(Strings, Decl(cls.js, 1, 5))
11 >a : Symbol(a, Decl(cls.js, 1, 17))
14 >b : Symbol(b, Decl(cls.js, 2, 11))
18 >Foo : Symbol(Foo, Decl(cls.js, 4, 2))
19 >Bar : Symbol(Bar, Decl(cls.js, 0, 5))
22 >module.exports : Symbol(module.exports, Decl(cls.js, 0, 0))
23 >module : Symbol(export=, Decl(cls.js, 5, 24))
24 >exports : Symbol(export=, Decl(cls.js, 5, 24))
[all …]
|
| D | abstractClassUnionInstantiation.symbols | 52 [ConcreteA, AbstractA, AbstractB].map(cls => new cls()); // should error
58 >cls : Symbol(cls, Decl(abstractClassUnionInstantiation.ts, 17, 38))
59 >cls : Symbol(cls, Decl(abstractClassUnionInstantiation.ts, 17, 38))
61 [AbstractA, AbstractB, ConcreteA].map(cls => new cls()); // should error
67 >cls : Symbol(cls, Decl(abstractClassUnionInstantiation.ts, 18, 38))
68 >cls : Symbol(cls, Decl(abstractClassUnionInstantiation.ts, 18, 38))
70 [ConcreteA, ConcreteB].map(cls => new cls()); // should work
75 >cls : Symbol(cls, Decl(abstractClassUnionInstantiation.ts, 19, 27))
76 >cls : Symbol(cls, Decl(abstractClassUnionInstantiation.ts, 19, 27))
78 [AbstractA, AbstractB].map(cls => new cls()); // should error
[all …]
|
| /third_party/mbedtls/scripts/mbedtls_dev/ |
| D | bignum_common.py | 208 def get_value_pairs(cls) -> Iterator[Tuple[str, str]]: argument
214 if cls.arity == 1:
215 yield from ((a, "0") for a in cls.input_values)
216 elif cls.arity == 2:
217 if cls.unique_combinations_only:
218 yield from combination_pairs(cls.input_values)
222 for a in cls.input_values
223 for b in cls.input_values
229 def generate_function_tests(cls) -> Iterator[test_case.TestCase]: argument
230 if cls.input_style not in cls.input_styles:
[all …]
|
| /third_party/protobuf/python/google/protobuf/internal/ |
| D | python_message.py | 107 def __new__(cls, name, bases, dictionary): argument
156 superclass = super(GeneratedProtocolMessageType, cls)
157 new_class = superclass.__new__(cls, name, bases, dictionary)
160 def __init__(cls, name, bases, dictionary): argument
183 assert existing_class is cls, (
188 cls._decoders_by_tag = {}
191 cls._decoders_by_tag[decoder.MESSAGE_SET_ITEM_TAG] = (
196 _AttachFieldHelpers(cls, field)
198 descriptor._concrete_class = cls # pylint: disable=protected-access
199 _AddEnumValues(descriptor, cls)
[all …]
|
| /third_party/rust/crates/regex/regex-syntax/src/hir/ |
| D | mod.rs | 560 let mut cls = ClassBytes::empty(); in dot() localVariable
561 cls.push(ClassBytesRange::new(b'\0', b'\x09')); in dot()
562 cls.push(ClassBytesRange::new(b'\x0B', b'\xFF')); in dot()
563 Hir::class(Class::Bytes(cls)) in dot()
565 let mut cls = ClassUnicode::empty(); in dot() localVariable
566 cls.push(ClassUnicodeRange::new('\0', '\x09')); in dot()
567 cls.push(ClassUnicodeRange::new('\x0B', '\u{10FFFF}')); in dot()
568 Hir::class(Class::Unicode(cls)) in dot()
582 let mut cls = ClassBytes::empty(); in any() localVariable
583 cls.push(ClassBytesRange::new(b'\0', b'\xFF')); in any()
[all …]
|
| /third_party/python/Lib/test/ |
| D | test_subclassinit.py | 10 def __init_subclass__(cls): argument
12 cls.initialized = True
24 def __init_subclass__(cls): argument
26 cls.initialized = True
36 def __init_subclass__(cls, **kwargs): argument
37 cls.kwargs = kwargs
46 def __init_subclass__(cls): argument
55 def __init_subclass__(cls, whatever): argument
64 def __init_subclass__(cls, **kwargs): argument
66 cls.initialized = cls
[all …]
|
| D | test_datetime.py | 28 for name, cls in module.__dict__.items():
29 if not isinstance(cls, type):
31 if issubclass(cls, unittest.TestCase):
32 test_classes.append(cls)
33 elif issubclass(cls, unittest.TestSuite):
34 suit = cls()
36 test_classes = sorted(set(test_classes), key=lambda cls: cls.__qualname__)
37 for cls in test_classes:
38 cls.__name__ += suffix
39 cls.__qualname__ += suffix
[all …]
|
| /third_party/python/Tools/c-analyzer/c_parser/ |
| D | info.py | 35 def _from_raw(cls, raw): argument
38 elif isinstance(raw, cls):
43 return cls(raw.lower())
48 def by_priority(cls, group=None): argument
50 return cls._ALL_BY_PRIORITY.copy()
52 return cls._TYPE_DECLS_BY_PRIORITY.copy()
54 return cls._ALL_DECLS_BY_PRIORITY.copy()
62 def is_type_decl(cls, kind): argument
63 if kind in cls.TYPES:
65 if not isinstance(kind, cls):
[all …]
|
| /third_party/protobuf/python/google/protobuf/ |
| D | service_reflection.py | 70 def __init__(cls, name, bases, dictionary): argument
92 service_builder.BuildService(cls)
93 cls.DESCRIPTOR = descriptor
106 def __init__(cls, name, bases, dictionary): argument
116 descriptor = dictionary.get(cls._DESCRIPTOR_KEY)
120 super(GeneratedServiceStubType, cls).__init__(name, bases, dictionary)
127 service_stub_builder.BuildServiceStub(cls)
149 def BuildService(self, cls): argument
163 self.cls = cls
164 cls.CallMethod = _WrapCallMethod
[all …]
|