PrimeIntellect/SWE-rebench-V2-Filtered-Easy-Verified huggingface dataset:
Repository: goccy/go-json (go)
Issue: Serializing struct with embedded interface results in malformed json
Example:
```
type I interface {
	Foo()
}

type A struct {
	I
	Val string
}

func TestStructWithEmbeddedInterface(t *testing.T) {
	var s A
	s.Val = "456"

	j1, _ := json.Marshal(s)  // This uses encoding/json.
	fmt.Println("expected", string(j1))

	j2, _ := goccyjson.Marshal(s)  // This uses this library.
	fmt.Println("actual", string(j2))
}
```

The code above will generate a json string that is not valid.
 
Expected result (using `encoding/json`):
`{"I":null,"Val":"456"}`

Actual result:
`{null,"Val":"456"}`

This can be reproduced with:
`github.com/goccy/go-json v0.10.0`
Pull request description: fix: fixed handling of anonymous fields other than struct
fix #426

Patch:
diff --git a/internal/encoder/compiler.go b/internal/encoder/compiler.go
index 3b3ff3f..3ae39ba 100644
--- a/internal/encoder/compiler.go
+++ b/internal/encoder/compiler.go
@@ -617,6 +617,13 @@ func (c *Compiler) structCode(typ *runtime.Type, isPtr bool) (*StructCode, error
 	return code, nil
 }
 
+func toElemType(t *runtime.Type) *runtime.Type {
+	for t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	return t
+}
+
 func (c *Compiler) structFieldCode(structCode *StructCode, tag *runtime.StructTag, isPtr, isOnlyOneFirstField bool) (*StructFieldCode, error) {
 	field := tag.Field
 	fieldType := runtime.Type2RType(field.Type)
@@ -626,7 +633,7 @@ func (c *Compiler) structFieldCode(structCode *StructCode, tag *runtime.StructTa
 		key:           tag.Key,
 		tag:           tag,
 		offset:        field.Offset,
-		isAnonymous:   field.Anonymous && !tag.IsTaggedKey,
+		isAnonymous:   field.Anonymous && !tag.IsTaggedKey && toElemType(fieldType).Kind() == reflect.Struct,
 		isTaggedKey:   tag.IsTaggedKey,
 		isNilableType: c.isNilableType(fieldType),
 		isNilCheck:    true,


Test patch:
diff --git a/encode_test.go b/encode_test.go
index 63740f3..3ff3fcb 100644
--- a/encode_test.go
+++ b/encode_test.go
@@ -2629,3 +2629,18 @@ func TestCustomMarshalForMapKey(t *testing.T) {
 	assertErr(t, err)
 	assertEq(t, "custom map key", string(expected), string(got))
 }
+
+func TestIssue426(t *testing.T) {
+	type I interface {
+		Foo()
+	}
+	type A struct {
+		I
+		Val string
+	}
+	var s A
+	s.Val = "456"
+
+	b, _ := json.Marshal(s)
+	assertEq(t, "unexpected result", `{"I":null,"Val":"456"}`, string(b))
+}
Repository: atlassian/changesets (ts)
Issue: @changesets/git: getChangedPackagesSinceRef always returns values
## Affected Packages

`@changesets/git`

## Problem

Untested with a monorepo, but calling `getChangedPackagesSinceRef` against a single package with no changes, results in the package being returned.

This is because `getChangedFilesSince(... fullPath: false)` will return `[""]`, rather than the expected `[]`.
`getChangedFilesSince(... fullPath: true)` will join that empty string with the path, and imply that the package has changed.

## Proposed solution

Filter empty strings from `getChangedFilesSince`
Pull request description: dont return paths for unchanged packages
Fixes #416 

Patch:
diff --git a/.changeset/curvy-ducks-end.md b/.changeset/curvy-ducks-end.md
new file mode 100644
index 0000000..75685fc
--- /dev/null
+++ b/.changeset/curvy-ducks-end.md
@@ -0,0 +1,5 @@
+---
+"@changesets/git": patch
+---
+
+Don't return paths for unchanged packages
diff --git a/packages/git/src/index.ts b/packages/git/src/index.ts
index 70bcb2b..0091ce2 100644
--- a/packages/git/src/index.ts
+++ b/packages/git/src/index.ts
@@ -73,7 +73,8 @@ async function getChangedFilesSince({
   const files = cmd.stdout
     .toString()
     .trim()
-    .split("\n");
+    .split("\n")
+    .filter(a => a);
   if (!fullPath) return files;
   return files.map(file => path.resolve(cwd, file));
 }


Test patch:
diff --git a/packages/git/src/index.test.ts b/packages/git/src/index.test.ts
index 25752de..dfb7652 100644
--- a/packages/git/src/index.test.ts
+++ b/packages/git/src/index.test.ts
@@ -208,13 +208,24 @@ describe("git", () => {
       await commit("added packageA package.json", cwd);
     });
 
-    it("should be empty if no changes", async () => {
+    it("should be empty if no changes (partial path)", async () => {
       const head = await spawn("git", ["rev-parse", "HEAD"], { cwd });
       const changedFiles = await getChangedFilesSince({
         ref: head.stdout.toString().trim(),
-        cwd
+        cwd,
+        fullPath: false
+      });
+      expect(changedFiles).toHaveLength(0);
+    });
+
+    it("should be empty if no changes (full path)", async () => {
+      const head = await spawn("git", ["rev-parse", "HEAD"], { cwd });
+      const changedFiles = await getChangedFilesSince({
+        ref: head.stdout.toString().trim(),
+        cwd,
+        fullPath: true
       });
-      expect(changedFiles.filter(a => a)).toHaveLength(0);
+      expect(changedFiles).toHaveLength(0);
     });
 
     it("should get list of files that have been committed", async () => {
Repository: platers/obsidian-linter (ts)
Issue: Date created gets reset when vault is cloned on another device
Since the date created uses the file creation date, it gets updated when the vault is cloned again. 

This can be fixed by only changing date created if it doesn't exist yet. I dont see a way to fix date modified.
Pull request description: only add date created if its not there
fixes #86 

Patch:
diff --git a/package.json b/package.json
index 7972774..08ac6a9 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,7 @@
     "build": "rollup --config rollup.config.js --environment BUILD:production",
     "test": "jest",
     "docs": "ts-node --project ./tsconfig-docs.json ./src/docs.ts",
-    "compile": "npm run build && npm run docs && npm run test",
+    "compile": "npm run build && npm run docs && npm run lint && npm run test",
     "lint": "eslint . --ext .ts --fix"
   },
   "keywords": [],
diff --git a/src/rules.ts b/src/rules.ts
index 710fae6..d5adf70 100644
--- a/src/rules.ts
+++ b/src/rules.ts
@@ -449,8 +449,7 @@ export const rules: Rule[] = [
         text = initYAML(text);
 
         return formatYAML(text, (text) => {
-          if (options['Date Created'] === true) {
-            text = text.replace(/\ndate created:.*\n/, '\n');
+          if (options['Date Created'] === true && !text.match(/\ndate created:.*\n/)) {
             const yaml_end = text.indexOf('\n---');
             const formatted_date = moment(options['metadata: file created time']).format(options['Format']);
             text = insert(text, yaml_end, `\ndate created: ${formatted_date}`);


Test patch:
diff --git a/src/test.ts b/src/test.ts
index f7b8e47..5d5d9a4 100644
--- a/src/test.ts
+++ b/src/test.ts
@@ -377,6 +377,21 @@ describe('Move Footnotes to the bottom', () => {
     expect(rulesDict['move-footnotes-to-the-bottom'].apply(before)).toBe(after);
   });
 });
+describe('yaml timestamp', () => {
+  it('Doesnt add date created if already there', () => {
+    const before = dedent`
+    ---
+    date created: 2019-01-01
+    ---
+    `;
+    const after = dedent`
+    ---
+    date created: 2019-01-01
+    ---
+    `;
+    expect(rulesDict['yaml-timestamp'].apply(before, {'Date Created': true})).toBe(after);
+  });
+});
 
 describe('Disabled rules parsing', () => {
   it('No YAML', () => {
Repository: dprint/dprint-plugin-typescript (rust)
Issue: dprint removes type arguments in `typeof` expressions
dprint removes type arguments to the target of `typeof` expressions, changing the meaning of the code.

dprint 0.31.1
dprint-plugin-typescript version: 0.73.1

**Input Code**

```ts
function getCtor(): typeof MyClass<Foo>;
```

**Expected Output**

```ts
function getCtor(): typeof MyClass<Foo>;
```

**Actual Output**

```ts
function getCtor(): typeof MyClass;
```

Pull request description: fix: emit TypeQuery type arguments
Fixes #426

Turns out this was more trivial than I expected it would be

Patch:
diff --git a/src/generation/generate.rs b/src/generation/generate.rs
index aab0713..9cc1eba 100644
--- a/src/generation/generate.rs
+++ b/src/generation/generate.rs
@@ -5852,6 +5852,9 @@ fn gen_type_query<'a>(node: &'a TsTypeQuery, context: &mut Context<'a>) -> Print
   items.push_str("typeof");
   items.push_signal(Signal::SpaceIfNotTrailing);
   items.extend(gen_node(node.expr_name.into(), context));
+  if let Some(type_args) = node.type_args {
+    items.extend(gen_node(type_args.into(), context));
+  }
   items
 }
 


Test patch:
diff --git a/tests/specs/issues/issue0426.txt b/tests/specs/issues/issue0426.txt
new file mode 100644
index 0000000..73a692d
--- /dev/null
+++ b/tests/specs/issues/issue0426.txt
@@ -0,0 +1,5 @@
+== should emit type arguments in typeof expressions ==
+function getCtor(): typeof MyClass<Foo>;
+
+[expect]
+function getCtor(): typeof MyClass<Foo>;