feat: support init and kw_only fields

Author: PrettyWood

crates/ty_python_semantic/resources/mdtest/dataclasses/dataclasses.md

@@ -137,6 +137,67 @@ class F:
         y: str
 ```
 
+Fields with `init=False` do not participate in the ordering check since they don't appear in
+`__init__`:
+
+```py
+@dataclass
+class GoodWithInitFalse:
+    x: int = 1
+    y: str = field(init=False)
+    z: float = 2.0
+
+@dataclass
+class BadWithInitFalse:
+    x: int = 1
+    y: str = field(init=False)
+    # error: [dataclass-field-order] "Required field `z` cannot be defined after fields with default values"
+    z: float
+```
+
+Keyword-only fields (using `kw_only=True`) also don't participate in the positional ordering check:
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+@dataclass
+class GoodWithKwOnly:
+    x: int = 1
+    y: str = field(kw_only=True)
+    z: float = field(kw_only=True, default=2.0)
+
+@dataclass
+class BadWithKwOnly:
+    x: int = 1
+    y: str = field(kw_only=True)
+    # error: [dataclass-field-order] "Required field `z` cannot be defined after fields with default values"
+    z: float
+```
+
+Fields after a `KW_ONLY` sentinel are also keyword-only and don't participate in ordering checks:
+
+```py
+from dataclasses import KW_ONLY
+
+@dataclass
+class GoodWithKwOnlySentinel:
+    x: int = 1
+    _: KW_ONLY
+    y: str
+    z: float = 2.0
+
+@dataclass
+class BadWithKwOnlySentinel:
+    x: int = 1
+    # error: [dataclass-field-order] "Required field `y` cannot be defined after fields with default values"
+    y: str
+    _: KW_ONLY
+    z: float
+```
+
 Pure class attributes (`ClassVar`) are not included in the signature of `__init__`:
 
 ```py

crates/ty_python_semantic/src/types/infer.rs

@@ -1365,27 +1365,37 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                 let mut kw_only_field_names = vec![];
                 let mut required_after_default_field_names = vec![];
                 let mut has_seen_default_field = false;
+                let mut kw_only_sentinel_seen = false;
 
                 for (
                     name,
                     Field {
                         declared_ty: field_ty,
                         default_ty,
+                        init,
+                        kw_only,
                         ..
                     },
                 ) in class.fields(self.db(), specialization, field_policy)
                 {
-                    // Check for KW_ONLY
+                    // Check for fields after KW_ONLY sentinel
                     if let Some(instance) = field_ty.into_nominal_instance() {
                         if instance
                             .class(self.db())
                             .is_known(self.db(), KnownClass::KwOnly)
                         {
                             kw_only_field_names.push(name.clone());
+                            kw_only_sentinel_seen = true;
                         }
                     }
 
-                    // Check field ordering
+                    // Check field ordering - only for fields that participate in positional `__init__` args
+                    // Skip `init=False` fields (don't appear in `__init__`)
+                    // Skip `kw_only` fields (go at end of `__init__` signature, not positional)
+                    // Skip fields that come after a `KW_ONLY` sentinel (they're keyword-only)
+                    if !init || kw_only == Some(true) || kw_only_sentinel_seen {
+                        continue;
+                    }
                     if default_ty.is_some() {
                         has_seen_default_field = true;
                     } else if has_seen_default_field {