diff --git a/package-lock.json b/package-lock.json index 934fe186db2..b0908c3e2c5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1221,9 +1221,9 @@ "license": "MIT" }, "node_modules/fast-uri": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.2.tgz", - "integrity": "sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==", + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.5.tgz", + "integrity": "sha512-gHwA1O9LDIcKunMKhObS/HimwtehO1nPUECKAu5TpKgaO19fcWEl4bliWe1jWxVFvIXztJjjQ4L8XQ1EU9f7Jw==", "dev": true, "funding": [ { diff --git a/src/api/json/catalog.json b/src/api/json/catalog.json index 1cfaa674838..94511580e2e 100644 --- a/src/api/json/catalog.json +++ b/src/api/json/catalog.json @@ -3854,6 +3854,12 @@ ], "url": "https://gitlab.com/gitlab-org/gitlab-foss/-/raw/master/app/assets/javascripts/editor/schema/ci.json" }, + { + "name": "GitLab Duo Workflow", + "description": "YAML configuration for GitLab Duo Workflows", + "fileMatch": [".gitlab/duo/flows/*.yaml"], + "url": "https://gitlab.com/gitlab-org/modelops/applied-ml/code-suggestions/ai-assist/-/raw/main/duo_workflow_service/schemas/v1/flow_config.schema.json" + }, { "name": "Gitpod Automations", "description": "Configuration for Gitpod Automations", @@ -4025,6 +4031,12 @@ "fileMatch": ["*.goff.yml", "*.goff.yaml", "*.goff.json", "*.goff.toml"], "url": "https://raw.githubusercontent.com/thomaspoignant/go-feature-flag/main/.schema/flag-schema.json" }, + { + "name": "gojo.yaml", + "description": "gojo project manifest (profiles, agents, schedules)", + "fileMatch": ["gojo.yaml", "**/.gojo/project.yaml"], + "url": "https://raw.githubusercontent.com/detroitpro/gojo/main/packages/contracts/schemas/gojo.project.schema.json" + }, { "name": "Goreleaser", "description": "Goreleaser configuration file", @@ -5699,6 +5711,12 @@ "v0.9.0": "https://github.com/bitol-io/open-data-product-standard/blob/main/schema/odps-json-schema-v0.9.0.json" } }, + { + "name": "Open Pentest Format", + "description": "OPF finding library or engagement export (*.opf.json): portable penetration test findings", + "fileMatch": ["*.opf.json"], + "url": "https://cairnsecurity.com/opf/schema/opf-1.1.schema.json" + }, { "name": "OpenSRM", "description": "Open Service Reliability Manifest - Define service reliability requirements as code", diff --git a/src/negative_test/github-workflow/reusable-workflow-input-must-declare-type.yaml b/src/negative_test/github-workflow/reusable-workflow-input-must-declare-type.yaml index ad69ae99582..e5ed9cd39a3 100644 --- a/src/negative_test/github-workflow/reusable-workflow-input-must-declare-type.yaml +++ b/src/negative_test/github-workflow/reusable-workflow-input-must-declare-type.yaml @@ -13,12 +13,14 @@ jobs: name: build and publish runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@ee0669bd1cc54295c223e0bb666b733df41de1c5 - name: satisfy constraings - run: echo 'constraints=${{ inputs.constraints }}' + env: + CONSTRAINTS: ${{ inputs.constraints }} + run: echo "constraints=$CONSTRAINTS" - name: build run: echo 'do build step' - name: publish - uses: example/example-publisher-action@v1 + uses: example/example-publisher-action@ee0669bd1cc54295c223e0bb666b733df41de1c5 with: token: ${{ secrets.api_token }} diff --git a/src/negative_test/global/must-use-string-error-message.json b/src/negative_test/global/must-use-string-error-message.json new file mode 100644 index 00000000000..ee09465e7da --- /dev/null +++ b/src/negative_test/global/must-use-string-error-message.json @@ -0,0 +1,5 @@ +{ + "sdk": { + "errorMessage": false + } +} diff --git a/src/negative_test/global/must-use-string-msbuild-sdk-version.json b/src/negative_test/global/must-use-string-msbuild-sdk-version.json new file mode 100644 index 00000000000..e255ccc3e7c --- /dev/null +++ b/src/negative_test/global/must-use-string-msbuild-sdk-version.json @@ -0,0 +1,5 @@ +{ + "msbuild-sdks": { + "Microsoft.Build.Traversal": 4.1 + } +} diff --git a/src/negative_test/global/must-use-string-sdk-paths.json b/src/negative_test/global/must-use-string-sdk-paths.json new file mode 100644 index 00000000000..41f2bd337d6 --- /dev/null +++ b/src/negative_test/global/must-use-string-sdk-paths.json @@ -0,0 +1,5 @@ +{ + "sdk": { + "paths": [".dotnet", 10] + } +} diff --git a/src/negative_test/global/rollforward-requires-version.json b/src/negative_test/global/rollforward-requires-version.json new file mode 100644 index 00000000000..9955c4713f0 --- /dev/null +++ b/src/negative_test/global/rollforward-requires-version.json @@ -0,0 +1,5 @@ +{ + "sdk": { + "rollForward": "latestFeature" + } +} diff --git a/src/schemas/json/global.json b/src/schemas/json/global.json index 6c2dc66b924..5fa5eaecbbe 100644 --- a/src/schemas/json/global.json +++ b/src/schemas/json/global.json @@ -5,15 +5,16 @@ "properties": { "sdk": { "type": "object", - "description": "Specify information about the SDK.", + "description": "Specifies information about the .NET SDK to select.\nhttps://learn.microsoft.com/dotnet/core/tools/global-json#sdk", "properties": { "version": { "type": "string", "pattern": "^(?0|[1-9]\\d*)\\.(?0|[1-9]\\d*)\\.(?0|[1-9]\\d*)(?:-(?(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+(?[0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$", - "description": "The version of the SDK to use." + "description": "The version of the .NET SDK to use. A full version number is required; wildcards and version ranges aren't supported.\nhttps://learn.microsoft.com/dotnet/core/tools/global-json#version" }, "allowPrerelease": { - "type": "boolean" + "type": "boolean", + "description": "Whether the SDK resolver should consider prerelease versions when selecting the SDK version to use.\nhttps://learn.microsoft.com/dotnet/core/tools/global-json#allowprerelease" }, "rollForward": { "type": "string", @@ -28,20 +29,56 @@ "latestMajor", "disable" ], - "default": "disable", - "description": "The roll-forward policy when selecting an SDK version, either as a fallback to accommodate missing a specific SDK version or as a directive to use a later version." + "description": "The roll-forward policy to use when selecting an SDK version. A version must also be specified unless this is set to 'latestMajor'. When omitted, the effective policy is 'patch' if a version is specified and 'latestMajor' otherwise.\nhttps://learn.microsoft.com/dotnet/core/tools/global-json#rollforward" + }, + "paths": { + "type": "array", + "description": "The locations to consider when searching for a compatible .NET SDK. Paths can be absolute, relative to global.json, or the special value '$host$'. Available since .NET 10 SDK.\nhttps://learn.microsoft.com/dotnet/core/tools/global-json#paths", + "items": { + "type": "string" + } + }, + "errorMessage": { + "type": "string", + "description": "A custom error message to display when the SDK resolver can't find a compatible .NET SDK. Available since .NET 10 SDK.\nhttps://learn.microsoft.com/dotnet/core/tools/global-json#errormessage" + } + }, + "dependencies": { + "rollForward": { + "anyOf": [ + { + "properties": { + "version": {} + }, + "required": ["version"] + }, + { + "properties": { + "rollForward": { + "enum": ["latestMajor"] + } + } + } + ] } } }, + "msbuild-sdks": { + "type": "object", + "description": "Controls project SDK versions in one place rather than in each individual project. Each property name is a project SDK name and its value is the version to use.\nhttps://learn.microsoft.com/dotnet/core/tools/global-json#msbuild-sdks", + "additionalProperties": { + "type": "string" + } + }, "test": { "type": "object", - "description": "Specify information related to testing", + "description": "Specifies information about tests.\nhttps://learn.microsoft.com/dotnet/core/tools/global-json#test", "properties": { "runner": { "type": "string", "enum": ["Microsoft.Testing.Platform", "VSTest"], "default": "VSTest", - "description": "The test runner/platform used by 'dotnet test' command." + "description": "The test runner that the 'dotnet test' command uses to discover and run tests. Available since .NET 10 SDK.\nhttps://learn.microsoft.com/dotnet/core/tools/global-json#runner" } } } diff --git a/src/schemas/json/package.json b/src/schemas/json/package.json index d12edd55877..62191d5ebda 100644 --- a/src/schemas/json/package.json +++ b/src/schemas/json/package.json @@ -1336,7 +1336,18 @@ }, "sideEffects": { "description": "Provides hints to the Webpack compiler, denoting which files in your project are \"pure\" and therefore safe to prune if unused.", - "type": "boolean" + "oneOf": [ + { + "type": "boolean" + }, + { + "type": "array", + "items": { + "type": "string" + }, + "uniqueItems": true + } + ] } }, "$id": "https://json.schemastore.org/package.json" diff --git a/src/schemas/json/ty.json b/src/schemas/json/ty.json index abf1078fdf1..19bbd549e1c 100644 --- a/src/schemas/json/ty.json +++ b/src/schemas/json/ty.json @@ -94,6 +94,10 @@ "strict-equality-semantics": { "description": "Configure ty's behavior regarding type inference and narrowing of equality\nchecks. Defaults to `false`.\n\nBy default, ty makes various assumptions about equality checks that match the\nintuitions of most Python programmers, but may not be fully sound in all situations.\nEnabling this option makes ty more conservative about these assumptions, making it\nless likely to infer `Literal[True]` or `Literal[False]` as the result of an\nequality check. This has various effects on type checking, including fewer type\nnarrowing opportunities and more conservative assumptions regarding control flow.\n\nOne way in which ty will by default make unsound assumptions is by narrowing an\nobject `x` of type `str` to `Literal[\"a\"]` after an `if x == \"a\"` check. This is\nunsound because a subclass of `str` with value `\"a\"` will (by default) compare equal\nto `\"a\"`, but will not be of type `Literal[\"a\"]`:\n\n```pycon\n>>> # `Literal[\"a\"]` can only be inhabited by instances of exactly `str`, not\n>>> # subclasses, but str subclasses compare equal by default:\n>>> class StringSubclass(str): ...\n...\n>>> StringSubclass(\"a\") == \"a\"\nTrue\n>>>\n>>> # This also applies to `StrEnum`s:\n>>> from enum import StrEnum\n>>> class MyEnum(StrEnum):\n... A = \"a\"\n...\n>>> MyEnum.A == \"a\"\nTrue\n```\n\nEnabling this option prevents the unsound narrowing of `x` to `Literal[\"a\"]`,\nand instead keeps it as `str`:\n\n```python\nfrom typing import Literal\n\ndef parse(value: str) -> Literal[\"a\"] | None:\n # with `strict-equality-semantics = true`, no narrowing will occur here,\n # and an error will be emitted on the `return` statement.\n if value == \"a\":\n return value\n return None\n```\n\nAnother assumption ty makes by default is that subclasses will never override `__eq__` or\n`__ne__`. This allows ty to narrow the following union based on an equality check, despite\nthe fact that an instance of a subclass of `Foo` could compare equal to `None`, and it's\nperfectly valid to pass an instance of a subclass into the `x` parameter of this function:\n\n```python\ndef narrow(x: Foo | None, other: Foo) -> None:\n if x == other:\n # with this option enabled, `x` will still have type `Foo | None` here,\n # since it is legal to subclass `Foo` and override its `__eq__` method.\n reveal_type(x)\n```\n\nMany operations in Python implicitly call `__eq__` under the hood; enabling this option\nwill also impact those operations. For example, this option will also impact narrowing from\n`in` checks, and narrowing in `match` statements that use value patterns:\n\n```python\ndef narrow_in(x: Foo | None, other: list[Foo]) -> None:\n if x in other:\n # with this option enabled, `x` will still have type `Foo | None` here,\n # since the `in` operator implicitly calls `__eq__` on each element of `other`.\n reveal_type(x)\n\n\ndef narrow_match(x: str) -> None:\n match x:\n case \"a\":\n # with this option enabled, `x` will still have type `str` here,\n # since this `case` branch will be taken by any object that compares\n # equal to `\"a\"`, including subclasses of `str`.\n reveal_type(x)\n```", "type": ["boolean", "null"] + }, + "strict-generic-narrowing": { + "description": "Whether ty should use strict narrowing for unspecialized generic classes in\n`isinstance()` and `issubclass()` checks, as well as `match` class patterns.\n\nWhen enabled, ty narrows to the top materialization of the class. For example,\n`isinstance(value, list)` narrows a value of type `object` to `Top[list[Unknown]]`,\nrepresenting the (infinite) union of all possible `list` specializations. Iterating\nover the list would yield values of type `object`.\n\nWhen disabled, ty uses gradual generic narrowing, preserving compatible type\narguments from the original type where possible. For example,\n`isinstance(value, list)` narrows a value of type `Sequence[int]` to `list[int]`.\nIf no specialization is available, the same check narrows a value of type `object`\nto `list[Unknown]`; items of any type can then be appended to the list. Class\npatterns such as `case list():` follow the same behavior.\n\nDefaults to `false`.", + "type": ["boolean", "null"] } }, "additionalProperties": false @@ -311,6 +315,16 @@ "Rules": { "type": "object", "properties": { + "abstract-and-final-method": { + "title": "detects methods that are both abstract and final", + "description": "## What it does\n\nChecks for methods decorated with both `@abstractmethod` and `@final`.\n\n## Why is this bad?\n\nAn abstract method must be overridden for a subclass to become concrete, but a final\nmethod cannot be overridden. Combining the decorators therefore makes it impossible\nfor a subclass to provide a concrete implementation.\n\n## Example\n\n```python\nfrom abc import ABC, abstractmethod\nfrom typing import final\n\n\nclass Base(ABC):\n @final\n @abstractmethod\n def method(self) -> None: ... # error\n```", + "default": "error", + "oneOf": [ + { + "$ref": "#/definitions/Level" + } + ] + }, "abstract-method-in-final-class": { "title": "detects `@final` classes with unimplemented abstract methods", "description": "## What it does\n\nChecks for `@final` classes that have unimplemented abstract methods.\n\n## Why is this bad?\n\nA class decorated with `@final` cannot be subclassed. If such a class has abstract\nmethods that are not implemented, the class can never be properly instantiated, as\nthe abstract methods can never be implemented (since subclassing is prohibited).\n\nAt runtime, instantiation of classes with unimplemented abstract methods is only\nprevented for classes that have `ABCMeta` (or a subclass of it) as their metaclass.\nHowever, type checkers also enforce this for classes that do not use `ABCMeta`, since\nthe intent for the class to be abstract is clear from the use of `@abstractmethod`.\n\n## Example\n\n```python\nfrom abc import ABC, abstractmethod\nfrom typing import final\n\n\nclass Base(ABC):\n @abstractmethod\n def method(self) -> int: ...\n\n\n@final\n# `Derived` does not implement `method`\nclass Derived(Base): # error\n pass\n```", @@ -822,7 +836,7 @@ }, "invalid-named-tuple": { "title": "detects invalid `NamedTuple` class definitions", - "description": "## What it does\n\nChecks for invalidly defined `NamedTuple` classes.\n\n## Why is this bad?\n\nAn invalidly defined `NamedTuple` class may lead to the type checker\ndrawing incorrect conclusions. It may also lead to `TypeError`s or\n`AttributeError`s at runtime.\n\n## Examples\n\nA class definition cannot combine `NamedTuple` with other base classes\nin multiple inheritance; doing so raises a `TypeError` at runtime. The sole\nexception to this rule is `Generic[]`, which can be used alongside `NamedTuple`\nin a class's bases list.\n\n```pycon\n>>> from typing import NamedTuple\n>>> class Foo(NamedTuple, object): ...\nTypeError: can only inherit from a NamedTuple type and Generic\n```\n\nFurther, `NamedTuple` field names cannot start with an underscore:\n\n```pycon\n>>> from typing import NamedTuple\n>>> class Foo(NamedTuple):\n... _bar: int\nValueError: Field names cannot start with an underscore: '_bar'\n```\n\n`NamedTuple` classes also have certain synthesized attributes (like `_asdict`, `_make`,\n`_replace`, etc.) that cannot be overwritten. Attempting to assign to these attributes\nwithout a type annotation will raise an `AttributeError` at runtime.\n\n```pycon\n>>> from typing import NamedTuple\n>>> class Foo(NamedTuple):\n... x: int\n... _asdict = 42\nAttributeError: Cannot overwrite NamedTuple attribute _asdict\n```", + "description": "## What it does\n\nChecks for invalidly defined `NamedTuple` classes.\n\n## Why is this bad?\n\nAn invalidly defined `NamedTuple` class may lead to the type checker\ndrawing incorrect conclusions. It may also lead to `TypeError`s or\n`AttributeError`s at runtime.\n\n## Examples\n\nA class definition cannot combine `NamedTuple` with other base classes\nin multiple inheritance; doing so raises a `TypeError` at runtime. The sole\nexception to this rule is `Generic[]`, which can be used alongside `NamedTuple`\nin a class's bases list.\n\n```pycon\n>>> from typing import NamedTuple\n>>> class Foo(NamedTuple, object): ...\nTypeError: can only inherit from a NamedTuple type and Generic\n```\n\nFurther, `NamedTuple` field names cannot start with an underscore:\n\n```pycon\n>>> from typing import NamedTuple\n>>> class Foo(NamedTuple):\n... _bar: int\nValueError: Field names cannot start with an underscore: '_bar'\n```\n\n`NamedTuple` classes also have certain synthesized attributes (like `_asdict`, `_make`,\n`_replace`, etc.) that cannot be overwritten. Attempting to assign to these attributes\nwithout a type annotation will raise an `AttributeError` at runtime.\n\n```pycon\n>>> from typing import NamedTuple\n>>> class Foo(NamedTuple):\n... x: int\n... _asdict = 42\nAttributeError: Cannot overwrite NamedTuple attribute _asdict\n```\n\nFinally, `NamedTuple` field annotations cannot use the `ClassVar` or `Final` type\nqualifiers. These qualifiers also cause a runtime error when annotations are evaluated eagerly:\n\n```pycon\n>>> from typing import ClassVar, NamedTuple\n>>> class Foo(NamedTuple):\n... x: ClassVar[int]\nTypeError: typing.ClassVar[int] is not valid as type argument\n```", "default": "error", "oneOf": [ { @@ -942,7 +956,7 @@ }, "invalid-type-alias-type": { "title": "detects invalid TypeAliasType definitions", - "description": "## What it does\n\nChecks for the creation of invalid `TypeAliasType`s\n\n## Why is this bad?\n\nThere are several requirements that you must follow when creating a `TypeAliasType`.\n\n## Examples\n\n```toml\n[environment]\npython-version = \"3.12\"\n```\n\n```python\nfrom typing import TypeAliasType\n\n\ndef get_name() -> str:\n return \"NewAlias\"\n\n\nIntOrStr = TypeAliasType(\"IntOrStr\", int | str) # okay\n# TypeAliasType name must be a string literal\nNewAlias = TypeAliasType(get_name(), int) # error\n```", + "description": "## What it does\n\nChecks for the creation of invalid `TypeAliasType`s\n\n## Why is this bad?\n\nThere are several requirements that you must follow when creating a `TypeAliasType`.\n\n## Examples\n\n```toml\n[environment]\npython-version = \"3.12\"\n```\n\n```python\nfrom typing import TypeAliasType, TypeVar\n\n\ndef get_name() -> str:\n return \"NewAlias\"\n\n\nIntOrStr = TypeAliasType(\"IntOrStr\", int | str) # okay\n# TypeAliasType name must be a string literal\nNewAlias = TypeAliasType(get_name(), int) # error\n\nT = TypeVar(\"T\")\nGenericAlias = TypeAliasType(\"GenericAlias\", list[T], type_params=(T,)) # okay\n# TypeAliasType type parameters must be type variables\nInvalidAlias = TypeAliasType(\"InvalidAlias\", list[T], type_params=(list[T],)) # error\n```", "default": "error", "oneOf": [ { @@ -1559,6 +1573,10 @@ } ] }, + "exclude-scripts": { + "description": "Whether to exclude files containing PEP 723 inline script metadata unless they are\nexplicitly passed on the command line.", + "type": ["boolean", "null"] + }, "include": { "description": "A list of files and directories to check. The `include` option\nfollows a similar syntax to `.gitignore` but reversed:\nIncluding a file or directory will make it so that it (and its contents)\nare type checked.\n\n- `./src/` matches only a directory\n- `./src` matches both files and directories\n- `src` matches a file or directory named `src`\n- `*` matches any (possibly empty) sequence of characters (except `/`).\n- `**` matches zero or more path components.\n This sequence **must** form a single path component, so both `**a` and `b**` are invalid and will result in an error.\n A sequence of more than two consecutive `*` characters is also invalid.\n- `?` matches any single character except `/`\n- `[abc]` matches any character inside the brackets. Character sequences can also specify ranges of characters, as ordered by Unicode,\n so e.g. `[0-9]` specifies any character between `0` and `9` inclusive. An unclosed bracket is invalid.\n\nAll paths are anchored relative to the project root (`src` only\nmatches `/src` and not `/test/src`).\n\n`exclude` takes precedence over `include`.", "anyOf": [ @@ -1573,18 +1591,6 @@ "respect-ignore-files": { "description": "Whether to automatically exclude files that are ignored by `.ignore`,\n`.gitignore`, `.git/info/exclude`, and global `gitignore` files.\nEnabled by default.", "type": ["boolean", "null"] - }, - "root": { - "description": "The root of the project, used for finding first-party modules.\n\nIf left unspecified, ty will try to detect common project layouts and initialize `src.root` accordingly.\nThe project root (`.`) is always included. Additionally, the following directories are included\nif they exist and are not packages (i.e. they do not contain `__init__.py` or `__init__.pyi` files):\n\n* `./src`\n* `./` (if a `.//` directory exists)\n* `./python`", - "anyOf": [ - { - "$ref": "#/definitions/RelativePathBuf" - }, - { - "type": "null" - } - ], - "deprecated": true } }, "additionalProperties": false diff --git a/src/test/global/all-options.json b/src/test/global/all-options.json new file mode 100644 index 00000000000..9ea4059f467 --- /dev/null +++ b/src/test/global/all-options.json @@ -0,0 +1,16 @@ +{ + "msbuild-sdks": { + "Cake.Sdk": "6.0.0", + "Microsoft.Build.Traversal": "4.1.0" + }, + "sdk": { + "allowPrerelease": false, + "errorMessage": "The required .NET SDK wasn't found. Please run ./install.sh to install it.", + "paths": [".dotnet", "$host$"], + "rollForward": "latestFeature", + "version": "10.0.100" + }, + "test": { + "runner": "Microsoft.Testing.Platform" + } +} diff --git a/src/test/global/latest-major-without-version.json b/src/test/global/latest-major-without-version.json new file mode 100644 index 00000000000..028f4dc440c --- /dev/null +++ b/src/test/global/latest-major-without-version.json @@ -0,0 +1,5 @@ +{ + "sdk": { + "rollForward": "latestMajor" + } +} diff --git a/src/test/global/valid-rollfoward.json b/src/test/global/valid-rollfoward.json index a598592f29a..28c3ce850a3 100644 --- a/src/test/global/valid-rollfoward.json +++ b/src/test/global/valid-rollfoward.json @@ -1,6 +1,7 @@ { "sdk": { "allowPrerelease": true, - "rollForward": "latestPatch" + "rollForward": "latestPatch", + "version": "3.0.100" } } diff --git a/src/test/package/sideEffects.json b/src/test/package/sideEffects-test.json similarity index 100% rename from src/test/package/sideEffects.json rename to src/test/package/sideEffects-test.json diff --git a/src/test/package/sideEffects-test2.json b/src/test/package/sideEffects-test2.json new file mode 100644 index 00000000000..b634a3e58cc --- /dev/null +++ b/src/test/package/sideEffects-test2.json @@ -0,0 +1,3 @@ +{ + "sideEffects": ["**/*.css"] +} diff --git a/src/test/pyproject/ty-sample-project.toml b/src/test/pyproject/ty-sample-project.toml index 81955d08bef..0be6a36eb4f 100644 --- a/src/test/pyproject/ty-sample-project.toml +++ b/src/test/pyproject/ty-sample-project.toml @@ -1,7 +1,4 @@ #:schema ../../schemas/json/pyproject.json -[tool.ty.src] -root = "src" - [tool.ty.rules] division-by-zero = "error" @@ -10,3 +7,4 @@ output-format = "concise" [tool.ty.environment] python-version = "3.13" +root = ["src"]