Add support for operation templates and operation signature reuse

common/changes/@cadl-lang/compiler/operation-templates_2022-05-25-12-20.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "@cadl-lang/compiler",
+      "comment": "Add support for operation templates and operation signature reuse",
+      "type": "minor"
+    }
+  ],
+  "packageName": "@cadl-lang/compiler"
+}

common/changes/@cadl-lang/rest/operation-templates_2022-05-25-13-10.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "@cadl-lang/rest",
+      "comment": "Skip templated operations when scanning for operation routes",
+      "type": "patch"
+    }
+  ],
+  "packageName": "@cadl-lang/rest"
+}

common/changes/cadl-vscode/operation-templates_2022-06-02-16-12.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "cadl-vscode",
+      "comment": "Update tmLanguage grammar for operation signature support",
+      "type": "minor"
+    }
+  ],
+  "packageName": "cadl-vscode"
+}

packages/cadl-vscode/src/tmlanguage.ts

@@ -388,20 +388,6 @@ const namespaceStatement: BeginEndRule = {
   patterns: [token, namespaceName, namespaceBody],
 };
 
-const functionName: MatchRule = {
-  key: "function-name",
-  scope: "entity.name.function.cadl",
-  match: identifier,
-};
-
-const operationName: BeginEndRule = {
-  key: "operation-name",
-  scope: meta,
-  begin: beforeIdentifier,
-  end: `((?=\\()|${universalEnd})`,
-  patterns: [token, functionName],
-};
-
 const operationParameters: BeginEndRule = {
   key: "operation-parameters",
   scope: meta,
@@ -416,22 +402,39 @@ const operationParameters: BeginEndRule = {
   patterns: [token, decorator, modelProperty, modelSpreadProperty, punctuationComma],
 };
 
-const operationStatement: BeginEndRule = {
-  key: "operation-statement",
+const operationHeritage: BeginEndRule = {
+  key: "operation-heritage",
   scope: meta,
-  begin: "\\b(op)\\b",
+  begin: "\\b(is)\\b",
   beginCaptures: {
     "1": { scope: "keyword.other.cadl" },
   },
   end: universalEnd,
+  patterns: [expression],
+};
+
+const operationSignature: IncludeRule = {
+  key: "operation-signature",
   patterns: [
-    token,
-    operationName,
+    typeArguments,
+    operationHeritage,
     operationParameters,
     typeAnnotation, // return type
   ],
 };
 
+const operationStatement: BeginEndRule = {
+  key: "operation-statement",
+  scope: meta,
+  begin: `\\b(op)\\b\\s+(${identifier})`,
+  beginCaptures: {
+    "1": { scope: "keyword.other.cadl" },
+    "2": { scope: "entity.name.function.cadl" },
+  },
+  end: universalEnd,
+  patterns: [token, operationSignature],
+};
+
 const interfaceMember: BeginEndRule = {
   key: "interface-member",
   scope: meta,
@@ -441,7 +444,7 @@ const interfaceMember: BeginEndRule = {
     "2": { scope: "entity.name.function.cadl" },
   },
   end: universalEnd,
-  patterns: [token, operationParameters, typeAnnotation],
+  patterns: [token, operationSignature],
 };
 
 const interfaceHeritage: BeginEndRule = {

packages/cadl-vscode/test/interface.test.ts

@@ -86,4 +86,24 @@ describe("vscode: tmlanguage: interfaces", () => {
       Token.punctuation.closeBrace,
     ]);
   });
+
+  it("interface operation that copies the signature of another operation", async () => {
+    const tokens = await tokenize(`
+    interface Foo {
+      bar is ResourceRead<Widget>
+    }`);
+
+    deepStrictEqual(tokens, [
+      Token.keywords.interface,
+      Token.identifiers.type("Foo"),
+      Token.punctuation.openBrace,
+      Token.identifiers.functionName("bar"),
+      Token.keywords.is,
+      Token.identifiers.type("ResourceRead"),
+      Token.punctuation.typeParameters.begin,
+      Token.identifiers.type("Widget"),
+      Token.punctuation.typeParameters.end,
+      Token.punctuation.closeBrace,
+    ]);
+  });
 });

packages/cadl-vscode/test/operation.test.ts

@@ -82,4 +82,37 @@ describe("vscode: tmlanguage: Operations", () => {
       Token.identifiers.type("string"),
     ]);
   });
+
+  it("operation that copies the signature of another operation", async () => {
+    const tokens = await tokenize("op foo is ResourceRead<Widget>");
+    deepStrictEqual(tokens, [
+      Token.keywords.operation,
+      Token.identifiers.functionName("foo"),
+      Token.keywords.is,
+      Token.identifiers.type("ResourceRead"),
+      Token.punctuation.typeParameters.begin,
+      Token.identifiers.type("Widget"),
+      Token.punctuation.typeParameters.end,
+    ]);
+  });
+
+  it("defining a templated operation signature", async () => {
+    const tokens = await tokenize(
+      "op ResourceRead<TResource> is ResourceReadBase<TResource, DefaultOptions>"
+    );
+    deepStrictEqual(tokens, [
+      Token.keywords.operation,
+      Token.identifiers.functionName("ResourceRead"),
+      Token.punctuation.typeParameters.begin,
+      Token.identifiers.type("TResource"),
+      Token.punctuation.typeParameters.end,
+      Token.keywords.is,
+      Token.identifiers.type("ResourceReadBase"),
+      Token.punctuation.typeParameters.begin,
+      Token.identifiers.type("TResource"),
+      Token.punctuation.comma,
+      Token.identifiers.type("DefaultOptions"),
+      Token.punctuation.typeParameters.end,
+    ]);
+  });
 });

packages/compiler/core/binder.ts

@@ -389,6 +389,7 @@ export function createBinder(program: Program, options: BinderOptions = {}): Bin
   function bindOperationStatement(statement: OperationStatementNode) {
     if (scope.kind !== SyntaxKind.InterfaceStatement) {
       declareSymbol(statement, SymbolFlags.Operation);
+      statement.locals = new SymbolTable();
     }
   }
 
@@ -451,6 +452,7 @@ function hasScope(node: Node): node is ScopeNode {
     case SyntaxKind.AliasStatement:
     case SyntaxKind.CadlScript:
     case SyntaxKind.InterfaceStatement:
+    case SyntaxKind.OperationStatement:
     case SyntaxKind.UnionStatement:
     case SyntaxKind.Projection:
     case SyntaxKind.ProjectionLambdaExpression: