Implement public-methods-well-defined-types ESLint rule

Co-authored-by: alexr00 <38270282+alexr00@users.noreply.github.com>

Author: Copilot

.eslintrc.local.js

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+const RULES_DIR = require('eslint-plugin-rulesdir');
+RULES_DIR.RULES_DIR = './build/eslint-rules';
+
+module.exports = {
+	extends: ['.eslintrc.base.json'],
+	env: {
+		browser: true,
+		node: true
+	},
+	parserOptions: {
+		project: 'tsconfig.eslint.json'
+	},
+	plugins: ['rulesdir'],
+	rules: {
+		'rulesdir/public-methods-well-defined-types': 'error'
+	}
+};

build/eslint-rules/index.js

@@ -0,0 +1,10 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+module.exports = {
+	'public-methods-well-defined-types': require('./public-methods-well-defined-types'),
+};

build/eslint-rules/public-methods-well-defined-types.js

@@ -0,0 +1,164 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+/**
+ * ESLint rule to enforce that public methods in exported classes return well-defined types.
+ * This rule ensures that no inline type (object literal, anonymous type, etc.) is returned
+ * from any public method.
+ */
+
+const { ESLintUtils } = require('@typescript-eslint/utils');
+
+module.exports = {
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce that public methods return well-defined types (no inline types)',
+			category: 'TypeScript',
+			recommended: false,
+		},
+		schema: [],
+		messages: {
+			inlineReturnType: 'Public method "{{methodName}}" should return a well-defined type, not an inline type. Consider defining an interface or type alias.',
+		},
+	},
+
+	create(context) {
+		/**
+		 * Check if a node represents an inline type that should be flagged
+		 */
+		function isInlineType(typeNode) {
+			if (!typeNode) return false;
+
+			switch (typeNode.type) {
+				// Object type literals: { foo: string, bar: number }
+				case 'TSTypeLiteral':
+					return true;
+
+				// Union types with inline object types: string | { foo: bar }
+				case 'TSUnionType':
+					return typeNode.types.some(isInlineType);
+
+				// Intersection types with inline object types: Base & { foo: bar }
+				case 'TSIntersectionType':
+					return typeNode.types.some(isInlineType);
+
+				// Tuple types: [string, number]
+				case 'TSTupleType':
+					return true;
+
+				// Mapped types: { [K in keyof T]: U }
+				case 'TSMappedType':
+					return true;
+
+				// Conditional types: T extends U ? X : Y (inline)
+				case 'TSConditionalType':
+					return true;
+
+				default:
+					return false;
+			}
+		}
+
+		/**
+		 * Check if a method is public (not private or protected)
+		 */
+		function isPublicMethod(node) {
+			// If no accessibility modifier is specified, it's public by default
+			if (!node.accessibility) return true;
+			return node.accessibility === 'public';
+		}
+
+		/**
+		 * Check if a class is exported
+		 */
+		function isExportedClass(node) {
+			// Check if the class declaration itself is exported
+			if (node.parent && node.parent.type === 'ExportNamedDeclaration') {
+				return true;
+			}
+			// Check if it's a default export
+			if (node.parent && node.parent.type === 'ExportDefaultDeclaration') {
+				return true;
+			}
+			return false;
+		}
+
+		return {
+			MethodDefinition(node) {
+				// Only check methods in exported classes
+				const classNode = node.parent.parent; // MethodDefinition -> ClassBody -> ClassDeclaration
+				if (!classNode || classNode.type !== 'ClassDeclaration' || !isExportedClass(classNode)) {
+					return;
+				}
+
+				// Only check public methods
+				if (!isPublicMethod(node)) {
+					return;
+				}
+
+				// Check if the method has a return type annotation
+				const functionNode = node.value;
+				if (!functionNode.returnType) {
+					return; // No explicit return type, skip
+				}
+
+				const returnTypeNode = functionNode.returnType.typeAnnotation;
+				
+				// Check if the return type is an inline type
+				if (isInlineType(returnTypeNode)) {
+					const methodName = node.key.type === 'Identifier' ? node.key.name : '<computed>';
+					context.report({
+						node: functionNode.returnType,
+						messageId: 'inlineReturnType',
+						data: {
+							methodName: methodName,
+						},
+					});
+				}
+			},
+
+			// Also check arrow function properties that are public methods
+			PropertyDefinition(node) {
+				// Only check properties in exported classes
+				const classNode = node.parent.parent; // PropertyDefinition -> ClassBody -> ClassDeclaration
+				if (!classNode || classNode.type !== 'ClassDeclaration' || !isExportedClass(classNode)) {
+					return;
+				}
+
+				// Only check public methods
+				if (!isPublicMethod(node)) {
+					return;
+				}
+
+				// Check if the property is an arrow function
+				if (node.value && node.value.type === 'ArrowFunctionExpression') {
+					const arrowFunction = node.value;
+					
+					// Check if the arrow function has a return type annotation
+					if (!arrowFunction.returnType) {
+						return; // No explicit return type, skip
+					}
+
+					const returnTypeNode = arrowFunction.returnType.typeAnnotation;
+					
+					// Check if the return type is an inline type
+					if (isInlineType(returnTypeNode)) {
+						const methodName = node.key.type === 'Identifier' ? node.key.name : '<computed>';
+						context.report({
+							node: arrowFunction.returnType,
+							messageId: 'inlineReturnType',
+							data: {
+								methodName: methodName,
+							},
+						});
+					}
+				}
+			}
+		};
+	},
+};

package.json

@@ -2145,7 +2145,7 @@
 					"command": "pr.copyVscodeDevPrLink",
 					"when": "github:inReviewMode && remoteName != codespaces && embedderIdentifier != github.dev"
 				},
-{
+				{
 					"command": "pr.copyPrLink",
 					"when": "false"
 				},
@@ -3332,7 +3332,6 @@
 					"command": "pr.openSessionLogFromDescription",
 					"when": "webviewId == PullRequestOverview && github:codingAgentMenu"
 				}
-
 			],
 			"chat/chatSessions": [
 				{
@@ -4054,6 +4053,7 @@
 		"eslint": "7.22.0",
 		"eslint-cli": "1.1.1",
 		"eslint-plugin-import": "2.22.1",
+		"eslint-plugin-rulesdir": "^0.2.2",
 		"event-stream": "^4.0.1",
 		"fork-ts-checker-webpack-plugin": "6.1.1",
 		"glob": "7.1.6",