@servicenow/sdk-build-core 2.1.3 → 2.2.1

package/src/plugins/util/ConfigurationFunction.ts

@@ -1,17 +1,4 @@
-import { Logger } from '@servicenow/sdk-project'
-import {
-    ArrowFunction,
-    CallExpression,
-    FunctionExpression,
-    Identifier,
-    Node,
-    ObjectLiteralExpression,
-    PropertyAccessExpression,
-    PropertyAssignment,
-    SyntaxKind,
-    TemplateExpression,
-    ts,
-} from 'ts-morph'
+import { Logger, ts } from '@servicenow/sdk-project'
 import { Context } from '../Context'
 import { EntityData, ObjectData } from '../behaviors'
 import { getCallExpressionName } from './CallExpression'
@@ -45,7 +32,7 @@ export type ComposerClass = {
 export class ConfigurationFunctionEntityData extends EntityData {
     constructor(
         private readonly config: ConfigEntity,
-        node: CallExpression
+        node: ts.CallExpression
     ) {
         super(
             'test',
@@ -73,10 +60,10 @@ export class ConfigurationFunctionEntityData extends EntityData {
  * ```
  */
 export class ConfigurationFunctionExtractor {
-    private rootNode: CallExpression
+    private rootNode: ts.CallExpression
     private context: Context
     private composerClass: ComposerClass
-    private identifiers: (Identifier | null)[]
+    private identifiers: (ts.Identifier | null)[]
 
     /**
      *
@@ -84,7 +71,7 @@ export class ConfigurationFunctionExtractor {
      * @param context context from the plugin this is called in
      * @param composerClass A class whose prototype will be used to validate the allowed functions within the configuration function
      */
-    constructor(rootNode: CallExpression, context: Context, composerClass: ComposerClass) {
+    constructor(rootNode: ts.CallExpression, context: Context, composerClass: ComposerClass) {
         this.rootNode = rootNode
         this.context = context
         this.composerClass = composerClass
@@ -94,11 +81,11 @@ export class ConfigurationFunctionExtractor {
     /**
      * Grabs the property access expression chain of a call expression, and protects against accidentally grabbing property access expressions in arguments of the call expression
      */
-    private getPropChain(ce: CallExpression): PropertyAccessExpression[] {
+    private getPropChain(ce: ts.CallExpression): ts.PropertyAccessExpression[] {
         // Do this to ensure we are only considering property access expressions that are apart of the chain and not potentially in the arguments of the function
-        const props = [ce.getFirstDescendantByKindOrThrow(SyntaxKind.PropertyAccessExpression)]
-        const childProps = (props[0] as PropertyAccessExpression).getDescendantsOfKind(
-            SyntaxKind.PropertyAccessExpression
+        const props = [ce.getFirstDescendantByKindOrThrow(ts.SyntaxKind.PropertyAccessExpression)]
+        const childProps = (props[0] as ts.PropertyAccessExpression).getDescendantsOfKind(
+            ts.SyntaxKind.PropertyAccessExpression
         )
         if (childProps.length > 0) {
             props.push(...childProps)
@@ -111,15 +98,15 @@ export class ConfigurationFunctionExtractor {
      *   v
      *   a.b.c.d({})
      */
-    private getFirstProp(ce: CallExpression): Identifier {
+    private getFirstProp(ce: ts.CallExpression): ts.Identifier {
         // Need to use this instead of just grabbing descendents cause the arguments of the call expression can also potentially have property access expressions which we don't want to consider
         const props = this.getPropChain(ce)
         if (props.length === 1) {
-            const ids = props[0]?.getChildrenOfKind(SyntaxKind.Identifier) as Identifier[]
-            return ids[0] as Identifier
+            const ids = props[0]?.getChildrenOfKind(ts.SyntaxKind.Identifier) as ts.Identifier[]
+            return ids[0] as ts.Identifier
         }
-        const lastProp = props[props.length - 1] as PropertyAccessExpression
-        return lastProp.getChildrenOfKind(SyntaxKind.Identifier)[0] as Identifier
+        const lastProp = props[props.length - 1] as ts.PropertyAccessExpression
+        return lastProp.getChildrenOfKind(ts.SyntaxKind.Identifier)[0] as ts.Identifier
     }
 
     /**
@@ -128,11 +115,11 @@ export class ConfigurationFunctionExtractor {
      *         v
      *   a.b.c.d({})
      */
-    private getLastProp(ce: CallExpression): Identifier {
+    private getLastProp(ce: ts.CallExpression): ts.Identifier {
         // Do not need special chain handling here like in getFirstProp cause we are always grabbing the property access expression from the top level regardless of chain length
-        const props = ce.getFirstDescendantByKindOrThrow(SyntaxKind.PropertyAccessExpression)
-        const ids = props.getChildrenOfKind(SyntaxKind.Identifier) as Identifier[]
-        return ids[ids.length - 1] as Identifier // Identifier is either the only one present or is the last of 2 so this should fetch it in either scenario
+        const props = ce.getFirstDescendantByKindOrThrow(ts.SyntaxKind.PropertyAccessExpression)
+        const ids = props.getChildrenOfKind(ts.SyntaxKind.Identifier) as ts.Identifier[]
+        return ids[ids.length - 1] as ts.Identifier // Identifier is either the only one present or is the last of 2 so this should fetch it in either scenario
     }
 
     /**
@@ -140,7 +127,7 @@ export class ConfigurationFunctionExtractor {
      * @param ce
      * @param parameterName
      */
-    private isValidCallExpression(ce: CallExpression, paramId: Identifier) {
+    private isValidCallExpression(ce: ts.CallExpression, paramId: ts.Identifier) {
         if (!paramId) {
             throw Error('No parameter provided to configuration function')
         }
@@ -165,7 +152,7 @@ export class ConfigurationFunctionExtractor {
         }
 
         // Verify that call expression has the expected number of arguments
-        const funcArgs = ce.getFirstDescendantByKind(SyntaxKind.SyntaxList)?.getChildren() as Node[]
+        const funcArgs = ce.getFirstDescendantByKind(ts.SyntaxKind.SyntaxList)?.getChildren() as ts.Node[]
         if (!funcArgs) {
             throw Error('Call expression had no arguments at all')
         }
@@ -174,7 +161,7 @@ export class ConfigurationFunctionExtractor {
             throw Error('Call expressions only support a single argument')
         }
 
-        if ((funcArgs[0] as Node).getKind() != SyntaxKind.ObjectLiteralExpression) {
+        if ((funcArgs[0] as ts.Node).getKind() != ts.SyntaxKind.ObjectLiteralExpression) {
             throw Error('Call expression must have an object as its argument')
         }
     }
@@ -186,7 +173,7 @@ export class ConfigurationFunctionExtractor {
      * @param identifier
      * @param data
      */
-    private findReferencedIdentifier(identifier: Identifier) {
+    private findReferencedIdentifier(identifier: ts.Identifier) {
         const idName = identifier.getSymbol()?.getName()
         // Identifier index lines up with step index, removed from step object so identifiers are not returned in extracted object
         for (let i = 0; i < this.identifiers.length; i++) {
@@ -200,29 +187,29 @@ export class ConfigurationFunctionExtractor {
         return -1
     }
 
-    private getRootIdentifier(prop: PropertyAccessExpression): Identifier {
-        const children = prop.getChildrenOfKind(SyntaxKind.PropertyAccessExpression)
+    private getRootIdentifier(prop: ts.PropertyAccessExpression): ts.Identifier {
+        const children = prop.getChildrenOfKind(ts.SyntaxKind.PropertyAccessExpression)
         if (children.length == 0) {
-            const id = prop.getFirstChildByKind(SyntaxKind.Identifier)
+            const id = prop.getFirstChildByKind(ts.SyntaxKind.Identifier)
             if (!id) {
                 throw Error('Could not find identifier in property access expression')
             }
             return id
         }
-        return this.getRootIdentifier(children[0] as PropertyAccessExpression)
+        return this.getRootIdentifier(children[0] as ts.PropertyAccessExpression)
     }
 
-    private parseValue(valueNode: Node): any {
-        if (valueNode.getKind() == SyntaxKind.ArrayLiteralExpression) {
+    private parseValue(valueNode: ts.Node): any {
+        if (valueNode.getKind() == ts.SyntaxKind.ArrayLiteralExpression) {
             const values: any[] = []
-            const syntaxList = valueNode.getFirstDescendantByKind(SyntaxKind.SyntaxList)
+            const syntaxList = valueNode.getFirstDescendantByKind(ts.SyntaxKind.SyntaxList)
             if (!syntaxList) {
                 return
             }
             const children = syntaxList.getChildren()
 
             for (const child of children) {
-                if (child.getKind() == SyntaxKind.CommaToken) {
+                if (child.getKind() == ts.SyntaxKind.CommaToken) {
                     continue
                 }
                 const value = this.parseValue(child)
@@ -231,13 +218,13 @@ export class ConfigurationFunctionExtractor {
             return values
         }
 
-        if (valueNode.getKind() == SyntaxKind.ObjectLiteralExpression) {
-            const objNode = valueNode as ObjectLiteralExpression
+        if (valueNode.getKind() == ts.SyntaxKind.ObjectLiteralExpression) {
+            const objNode = valueNode as ts.ObjectLiteralExpression
             return this.objNodeToJSON(objNode)
         }
 
-        if (valueNode.getKind() == SyntaxKind.PropertyAccessExpression) {
-            const propNode = valueNode as PropertyAccessExpression
+        if (valueNode.getKind() == ts.SyntaxKind.PropertyAccessExpression) {
+            const propNode = valueNode as ts.PropertyAccessExpression
             const identifier = this.getRootIdentifier(propNode)
             const refIdentifierIndex = this.findReferencedIdentifier(identifier)
             if (refIdentifierIndex == -1) {
@@ -249,9 +236,9 @@ export class ConfigurationFunctionExtractor {
             return { __references: refIdentifierIndex, __value: parsedValue[parsedValue.length - 1] }
         }
 
-        if (valueNode.getKind() == SyntaxKind.TemplateExpression) {
-            // console.info(`literal: ${(valueNode as TemplateExpression).getVal}`)
-            const templateNode = valueNode as TemplateExpression
+        if (valueNode.getKind() == ts.SyntaxKind.TemplateExpression) {
+            // console.info(`literal: ${(valueNode as ts.TemplateExpression).getVal}`)
+            const templateNode = valueNode as ts.TemplateExpression
             const templateValue = [templateNode.getHead().getLiteralText()]
             templateNode.getTemplateSpans().forEach((s) => {
                 templateValue.push(this.parseValue(s.getExpression()))
@@ -262,13 +249,13 @@ export class ConfigurationFunctionExtractor {
 
         // A variety of Identifiers. Will be handled here
         // TODO: This is swallowing diagnostics and not handling the case where no data was extracted
-        return this.context.extractAst(valueNode)['data'][0]?.getValue()
+        return this.context.extractAst(valueNode)['data']?.getValue()
     }
 
-    private getKVPair(prop: PropertyAssignment) {
+    private getKVPair(prop: ts.PropertyAssignment) {
         const props = prop.getChildren()
-        const keyNode = props[0] as Node<ts.Node>
-        const valueNode = props[2] as Node<ts.Node>
+        const keyNode = props[0] as ts.Node
+        const valueNode = props[2] as ts.Node
 
         const key = (keyNode as any).getLiteralValue ? (keyNode as any).getLiteralValue() : keyNode.getText()
         const value = this.parseValue(valueNode)
@@ -279,18 +266,18 @@ export class ConfigurationFunctionExtractor {
         return { key: undefined, value: undefined }
     }
 
-    private objNodeToJSON(obj: ObjectLiteralExpression | undefined): { [name: string]: any } {
+    private objNodeToJSON(obj: ts.ObjectLiteralExpression | undefined): { [name: string]: any } {
         if (!obj) {
             throw Error('objNodeToJSON received an undefined object node')
         }
-        const syntaxList = obj.getFirstDescendantByKind(SyntaxKind.SyntaxList)
+        const syntaxList = obj.getFirstDescendantByKind(ts.SyntaxKind.SyntaxList)
 
         if (!syntaxList) {
             throw Error('objNodeToJSON could not find a syntax list in the ObjectLiteralExpression')
         }
 
         const json = {}
-        syntaxList.getChildrenOfKind(SyntaxKind.PropertyAssignment).forEach((arg) => {
+        syntaxList.getChildrenOfKind(ts.SyntaxKind.PropertyAssignment).forEach((arg) => {
             const propArg = arg
             const { key, value } = this.getKVPair(propArg)
             // TODO: What if the value is actually undefined?
@@ -301,35 +288,35 @@ export class ConfigurationFunctionExtractor {
         return json
     }
 
-    private getName(node: CallExpression) {
+    private getName(node: ts.CallExpression) {
         // This may not be robust but should be a good enough
         const lastProp = this.getLastProp(node)
         return lastProp.getText()
     }
 
-    private getConfigFunctionComponents(kind: string, node: CallExpression<ts.CallExpression>) {
+    private getConfigFunctionComponents(kind: string, node: ts.CallExpression) {
         kind
         const configArgs = node.getArguments()
         if (configArgs.length != 2) {
             throw Error('The plugin must have exactly 2 arguments')
         }
 
-        if ((configArgs[0] as any).getKind() != SyntaxKind.ObjectLiteralExpression) {
+        if ((configArgs[0] as any).getKind() != ts.SyntaxKind.ObjectLiteralExpression) {
             throw Error("The plugin's first argument was not an object")
         }
 
         if (
-            (configArgs[1] as any).getKind() != SyntaxKind.ArrowFunction &&
-            (configArgs[1] as any).getKind() != SyntaxKind.FunctionExpression
+            (configArgs[1] as any).getKind() != ts.SyntaxKind.ArrowFunction &&
+            (configArgs[1] as any).getKind() != ts.SyntaxKind.FunctionExpression
         ) {
             throw Error("The plugin's second argument was not a function")
         }
 
-        const objectArg = configArgs[0] as ObjectLiteralExpression
-        const configFunction = configArgs[1] as ArrowFunction | FunctionExpression
+        const objectArg = configArgs[0] as ts.ObjectLiteralExpression
+        const configFunction = configArgs[1] as ts.ArrowFunction | ts.FunctionExpression
 
         // TODO: This is swallowing diagnostics and not handling the case where no data was extracted
-        const objectArgValue = this.context.extractAst(objectArg!)['data'][0]?.getValue()
+        const objectArgValue = this.context.extractAst(objectArg!)['data']?.getValue()
 
         if (!('$id' in objectArgValue)) {
             throw Error('No $id defined in first argument')
@@ -337,25 +324,25 @@ export class ConfigurationFunctionExtractor {
 
         const parameters = configFunction.getParameters()
         // Checking the type is parameter is probably redundant but can not hurt
-        if (parameters.length != 1 || !parameters[0] || parameters[0].getKind() != SyntaxKind.Parameter) {
+        if (parameters.length != 1 || !parameters[0] || parameters[0].getKind() != ts.SyntaxKind.Parameter) {
             throw Error('Configuration function must have an parameter as its only argument')
         }
 
-        const paramId = parameters[0].getChildrenOfKind(SyntaxKind.Identifier)[0] as Identifier
-        const block = configFunction.getFirstChildByKind(SyntaxKind.Block)
+        const paramId = parameters[0].getChildrenOfKind(ts.SyntaxKind.Identifier)[0] as ts.Identifier
+        const block = configFunction.getFirstChildByKind(ts.SyntaxKind.Block)
         if (!block) {
             throw Error(`Failed to find block in configuration function`)
         }
 
-        const syntaxList = block.getFirstChildByKind(SyntaxKind.SyntaxList)
+        const syntaxList = block.getFirstChildByKind(ts.SyntaxKind.SyntaxList)
         if (!syntaxList) {
             throw Error(`Failed to find syntax list in configuration function`)
         }
         return { paramId, syntaxList, objectArgValue }
     }
 
-    private extractCallExpression(node: Node, paramId: Identifier) {
-        const callExpressions = node.getDescendantsOfKind(SyntaxKind.CallExpression)
+    private extractCallExpression(node: ts.Node, paramId: ts.Identifier) {
+        const callExpressions = node.getDescendantsOfKind(ts.SyntaxKind.CallExpression)
 
         if (callExpressions.length == 0) {
             throw Error(`Expression statement did not have any call expression`)
@@ -365,7 +352,7 @@ export class ConfigurationFunctionExtractor {
             throw Error(`Found more than one call expression inside of an expression statement`)
         }
 
-        const callExpression = callExpressions[0] as CallExpression
+        const callExpression = callExpressions[0] as ts.CallExpression
         this.isValidCallExpression(callExpression, paramId)
         return callExpression
     }
@@ -410,7 +397,7 @@ export class ConfigurationFunctionExtractor {
         syntaxList.getChildren().forEach((statement) => {
             try {
                 switch (statement.getKind()) {
-                    case SyntaxKind.ExpressionStatement: {
+                    case ts.SyntaxKind.ExpressionStatement: {
                         /**
                          * (param) => {
                          * param.foo({arg: 'value'}) <- Expression statement
@@ -422,41 +409,45 @@ export class ConfigurationFunctionExtractor {
                         const ce = this.extractCallExpression(statement, paramId)
                         data[stepNumber++] = {
                             name: this.getName(ce),
-                            info: this.objNodeToJSON(ce.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression)),
+                            info: this.objNodeToJSON(
+                                ce.getFirstDescendantByKind(ts.SyntaxKind.ObjectLiteralExpression)
+                            ),
                         }
                         this.identifiers.push(null)
                         break
                     }
-                    case SyntaxKind.VariableStatement: {
+                    case ts.SyntaxKind.VariableStatement: {
                         /**
                          * (param) => {
                          * const output = param.foo({arg: 'value'}) <- Variable statement
                          * }
                          */
                         const ce = this.extractCallExpression(statement, paramId)
-                        const variableDeclaration = statement.getFirstDescendantByKind(SyntaxKind.VariableDeclaration)
+                        const variableDeclaration = statement.getFirstDescendantByKind(
+                            ts.SyntaxKind.VariableDeclaration
+                        )
 
                         if (!variableDeclaration) {
                             throw Error('Could not find variable declaration in variable statement')
                         }
 
                         const assignment = variableDeclaration.getChildren() // Format: identifier, =, value
-                        const identifier = assignment[0] as Identifier
-                        const value = assignment[2] as CallExpression // Already been validated above to be a valid call expression
+                        const identifier = assignment[0] as ts.Identifier
+                        const value = assignment[2] as ts.CallExpression // Already been validated above to be a valid call expression
 
                         data[stepNumber++] = {
                             name: this.getName(ce),
                             info: this.objNodeToJSON(
-                                value.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression)
+                                value.getFirstDescendantByKind(ts.SyntaxKind.ObjectLiteralExpression)
                             ),
                         }
                         this.identifiers.push(identifier)
                         break
                     }
-                    case SyntaxKind.MultiLineCommentTrivia:
+                    case ts.SyntaxKind.MultiLineCommentTrivia:
                         /** This is a multiline comment */
                         break
-                    case SyntaxKind.SingleLineCommentTrivia:
+                    case ts.SyntaxKind.SingleLineCommentTrivia:
                         // This is a single line comment
                         break
                     default:

package/src/plugins/util/ObjectLiteral.ts

@@ -1,4 +1,4 @@
-import * as ts from 'ts-morph'
+import { ts } from '@servicenow/sdk-project'
 
 /**
  * Retrieves the property assignment with the specified name and subpath from the given node.

package/src/util/Debug.ts

@@ -11,9 +11,8 @@ export function inspect(val: unknown, depth = 2) {
 }
 
 export function debugData(data: ({ data: unknown } | Data)[], logger: Logger, message = 'DATA:') {
-    logger.info(message)
-    logger.info(
-        inspect(
+    logger.debug(
+        `${message} ${inspect(
             data.map((d) => {
                 if (d instanceof Data) {
                     return d.getValue()
@@ -22,25 +21,23 @@ export function debugData(data: ({ data: unknown } | Data)[], logger: Logger, me
                 }
             }),
             5
-        )
+        )}`
     )
 }
 
 export function debugDocuments(documents: Document[], logger: Logger, message = 'DOCUMENTS:') {
-    logger.info(message)
-    logger.info(
-        inspect(
+    logger.debug(
+        `${message} ${inspect(
             documents.map((d) => {
                 const { node, ...rest } = d
                 node
                 return rest
             }),
             5
-        )
+        )}`
     )
 }
 
 export function debugFiles(files: File[], logger: Logger, message = 'FILES:') {
-    logger.info(message)
-    logger.info(inspect(files, 5))
+    logger.debug(`${message}: ${inspect(files, 5)}`)
 }

package/src/util/Directive.ts

@@ -0,0 +1,123 @@
+import { ts, tsc, Diagnostic } from '@servicenow/sdk-project'
+import { Context } from '../plugins/Context'
+import { FluentDiagnostic } from '../plugins'
+
+const FluentDisableSyncDirective = '@fluent-disable-sync'
+const FluentDisableSyncForFileDirective = '@fluent-disable-sync-for-file'
+const fluentCommentDirectiveRegEx = /^\/\/\/?\s*@fluent-ignore\b/
+
+enum FluentDirectiveType {
+    Ignore = 'ignore',
+}
+export type FluentDirective = {
+    filePath: string
+    start: number
+    type: FluentDirectiveType
+}
+
+function getDirectiveFromCommentText(text: string) {
+    const directiveRegex = /^.*(\/{2,}|\/\*{1,})*\s*(@fluent-[-_a-zA-Z0-9]+).*$/m
+    return text.match(directiveRegex)?.[2]
+}
+
+function getDirectivesFromAncestors(node: ts.Node) {
+    return [node].concat(node.getAncestors()).flatMap(
+        (ancestor) =>
+            ancestor
+                .getLeadingCommentRanges()
+                .map((comment) => getDirectiveFromCommentText(comment.getText()))
+                .filter((directive) => directive) as string[]
+    )
+}
+
+function isFluentDirective(text: string, kind: tsc.CommentKind) {
+    text = text.trim()
+    if (kind === tsc.SyntaxKind.SingleLineCommentTrivia) {
+        return fluentCommentDirectiveRegEx.test(text)
+    }
+    text = text.substring(2, text.length - 2).trim()
+    return /^@fluent-ignore\b/.test(text)
+}
+
+function parseFluentDirectives(filePath: string, context: Context) {
+    const fluentDirectives: FluentDirective[] = []
+    const visitedRange = new Set<number>()
+    const sourceFile = context.compiler.getSourceFile(filePath)
+    if (sourceFile) {
+        const sourceCode = sourceFile.getFullText()
+        context.compiler.visitNodeTree(sourceFile, (node) => {
+            ;[
+                ...(tsc.getLeadingCommentRanges(sourceCode, node.getFullStart()) ?? []),
+                ...(tsc.getTrailingCommentRanges(sourceCode, node.getFullStart()) ?? []),
+            ].forEach((range) => {
+                if (
+                    !visitedRange.has(range.pos) &&
+                    isFluentDirective(sourceCode.substring(range.pos, range.end), range.kind)
+                ) {
+                    fluentDirectives.push({
+                        filePath,
+                        start: range.pos,
+                        type: FluentDirectiveType.Ignore,
+                    })
+                    visitedRange.add(range.pos)
+                }
+            })
+        })
+    }
+    return fluentDirectives
+}
+
+export function syncDisabledForNode(node: ts.Node) {
+    return getDirectivesFromAncestors(node).some((directive) => directive === FluentDisableSyncDirective)
+}
+
+export function syncDisabledForFile(sourceFile: ts.SourceFile) {
+    return sourceFile
+        .getStatements()?.[0]
+        ?.getLeadingCommentRanges()
+        .map((comment) => getDirectiveFromCommentText(comment.getText()))
+        .some((directive) => directive === FluentDisableSyncForFileDirective)
+}
+
+export function applyFluentDirectives(context: Context, diagnostics: Diagnostic[]) {
+    const directiveCache = new Map<string, FluentDirective[]>()
+    const filteredDiagnostics = diagnostics.filter((diagnostic) => {
+        const filePath = diagnostic.file.getFilePath()
+        let fluentDirectives = directiveCache.get(filePath)
+        if (!fluentDirectives) {
+            fluentDirectives = parseFluentDirectives(filePath, context)
+            directiveCache.set(filePath, fluentDirectives)
+        }
+        let allowDiagnostic = true
+        for (const directive of fluentDirectives) {
+            const { line: direcLine } = diagnostic.file.getLineAndColumnAtPos(directive.start)
+            const { line: diagLine } = diagnostic.file.getLineAndColumnAtPos(diagnostic.position.start)
+            if (direcLine + 1 === diagLine) {
+                allowDiagnostic = false
+                break
+            }
+        }
+        return allowDiagnostic
+    })
+
+    return filteredDiagnostics
+}
+
+export function getDirectiveDiagnostics(node: ts.Node): FluentDiagnostic[] {
+    // Currently, the @fluent-disable-sync directive is only allowed before a CallExpression
+    // If we see it, within one (say, in a PropertyAssignment), we should flag it
+    if (node.isKind(ts.SyntaxKind.CallExpression)) {
+        return node
+            .getDescendantsOfKind(ts.SyntaxKind.SingleLineCommentTrivia)
+            .filter((commentNode) => getDirectiveFromCommentText(commentNode.getText()) === FluentDisableSyncDirective)
+            .map((n) => {
+                return new FluentDiagnostic(
+                    n,
+                    `${FluentDisableSyncDirective} directive only allowed before a call expression`,
+                    { level: Diagnostic.Level.Warn }
+                )
+            })
+    } else {
+        return []
+    }
+}

package/src/util/Util.ts

@@ -1,5 +1,4 @@
-import * as path from 'path'
-import { FileSystem } from '@servicenow/sdk-project'
+import { FileSystem, path } from '@servicenow/sdk-project'
 
 export const NOW_DIR = '.now'
 

package/src/util/index.ts

@@ -3,3 +3,4 @@ export * from './Util'
 export * from './XMLUploadParser'
 export * from './XMLJsonBuilder'
 export * from './Scope'
+export * from './Directive'