Add warning diagnostic when using V2 api

packages/pyright-internal/src/analyzer/binder.ts

@@ -111,6 +111,7 @@ import {
     VariableDeclaration,
 } from './declaration';
 import { ImplicitImport, ImportResult, ImportType } from './importResult';
+import { device, maybeAddMicrobitVersionWarningBinderWrapper } from './microbitUtils';
 import * as ParseTreeUtils from './parseTreeUtils';
 import { ParseTreeWalker } from './parseTreeWalker';
 import { NameBindingType, Scope, ScopeType } from './scope';
@@ -386,6 +387,19 @@ export class Binder extends ParseTreeWalker {
             }
         }
 
+        // Add warning diagnostic for V2 micro:bit modules.
+        maybeAddMicrobitVersionWarningBinderWrapper(importResult.importName, () =>
+            this._addDiagnostic(
+                this._fileInfo.diagnosticRuleSet.reportMicrobitV2ApiUse,
+                DiagnosticRule.reportMicrobitV2ApiUse,
+                Localizer.Diagnostic.microbitV2ModuleUse().format({
+                    moduleName: importResult.importName,
+                    device,
+                }),
+                node
+            )
+        );
+
         return true;
     }
 

packages/pyright-internal/src/analyzer/microbitUtils.ts

@@ -0,0 +1,156 @@
+import { DiagnosticLevel } from '../common/configOptions';
+import { Diagnostic } from '../common/diagnostic';
+import { DiagnosticRule } from '../common/diagnosticRules';
+import { Localizer } from '../localization/localize';
+import { NameNode, ParseNode } from '../parser/parseNodes';
+import { AnalyzerFileInfo } from './analyzerFileInfo';
+import * as AnalyzerNodeInfo from './analyzerNodeInfo';
+import { isClass, isFunction, isModule, isOverloadedFunction, Type } from './types';
+
+type AddDiagnostic = (
+    diagLevel: DiagnosticLevel,
+    rule: string,
+    message: string,
+    node: ParseNode
+) => Diagnostic | undefined;
+
+export const device = 'micro:bit V1';
+
+function getNames(type: Type) {
+    if (isFunction(type) || isClass(type)) {
+        return {
+            moduleName: type.details.moduleName,
+            name: type.details.name,
+        };
+    }
+    if (isOverloadedFunction(type)) {
+        return {
+            moduleName: type.overloads[0].details.moduleName,
+            name: type.overloads[0].details.name,
+        };
+    }
+    return {
+        moduleName: '',
+        name: '',
+    };
+}
+
+function usesMicrobitV2Api(moduleName: string, name?: string) {
+    return (
+        ['log', 'microbit.microphone', 'microbit.speaker', 'power'].includes(moduleName) ||
+        (moduleName === 'microbit' &&
+            ['run_every', 'set_volume', 'Sound', 'SoundEvent', 'pin_logo', 'pin_speaker'].includes(name ?? '')) ||
+        (moduleName === 'microbit.audio' && name === 'SoundEffect') ||
+        (moduleName === 'neopixel' && ['fill', 'write'].includes(name ?? ''))
+    );
+}
+
+function getFileInfo(node: ParseNode): AnalyzerFileInfo {
+    return AnalyzerNodeInfo.getFileInfo(node);
+}
+
+function getDiagLevel(fileInfo: AnalyzerFileInfo): DiagnosticLevel {
+    return fileInfo.diagnosticRuleSet.reportMicrobitV2ApiUse;
+}
+
+function addModuleVersionWarning(addDiagnostic: AddDiagnostic, moduleName: string, node: ParseNode) {
+    const fileInfo = getFileInfo(node);
+    addDiagnostic(
+        getDiagLevel(fileInfo),
+        DiagnosticRule.reportMicrobitV2ApiUse,
+        Localizer.Diagnostic.microbitV2ModuleUse().format({
+            moduleName: moduleName,
+            device,
+        }),
+        node
+    );
+}
+
+function addModuleMemberVersionWarning(
+    addDiagnostic: AddDiagnostic,
+    name: string,
+    moduleName: string,
+    node: ParseNode
+) {
+    const fileInfo = getFileInfo(node);
+    addDiagnostic(
+        getDiagLevel(fileInfo),
+        DiagnosticRule.reportMicrobitV2ApiUse,
+        Localizer.Diagnostic.microbitV2ModuleMemberUse().format({
+            name,
+            moduleName,
+            device,
+        }),
+        node
+    );
+}
+
+function addClassMethodVersionWarning(
+    addDiagnostic: AddDiagnostic,
+    methodName: string,
+    className: string,
+    node: ParseNode
+) {
+    const fileInfo = getFileInfo(node);
+    addDiagnostic(
+        getDiagLevel(fileInfo),
+        DiagnosticRule.reportMicrobitV2ApiUse,
+        Localizer.Diagnostic.microbitV2ClassMethodUse().format({
+            methodName,
+            className,
+            device,
+        }),
+        node
+    );
+}
+
+export function maybeAddMicrobitVersionWarning(
+    type: Type,
+    node: ParseNode,
+    addDiagnostic: AddDiagnostic,
+    memberName?: string
+) {
+    if (isModule(type)) {
+        if (usesMicrobitV2Api(type.moduleName, memberName)) {
+            addModuleVersionWarning(addDiagnostic, type.moduleName, node);
+        }
+    }
+
+    const moduleName = getNames(type).moduleName;
+    let name = getNames(type).name;
+    if (!moduleName && !name) {
+        return;
+    }
+
+    // Special case pin_logo and pin_speaker.
+    if (name === 'MicroBitAnalogDigitalPin' && (node as NameNode).value === 'pin_speaker') {
+        name = 'pin_speaker';
+    }
+    if (name === 'MicroBitTouchPin' && (node as NameNode).value === 'pin_logo') {
+        name = 'pin_logo';
+    }
+
+    if (usesMicrobitV2Api(moduleName, name)) {
+        if (isFunction(type) && type.boundToType) {
+            const className = type.boundToType?.details.name;
+            addClassMethodVersionWarning(addDiagnostic, name, className, node);
+            return;
+        }
+
+        if (isClass(type) && type.includeSubclasses) {
+            // Bail. Example, we only want to warn for microbit.Sound once and not again for microbit.Sound.GIGGLE.
+            return;
+        }
+
+        // The type must be a function, overloaded function or class at this point.
+        addModuleMemberVersionWarning(addDiagnostic, name, moduleName, node);
+    }
+}
+
+// Required as passing in this._addDiagnostic results in errors.
+// See binder.ts for use.
+export function maybeAddMicrobitVersionWarningBinderWrapper(moduleName: string, callback: () => void) {
+    if (usesMicrobitV2Api(moduleName)) {
+        callback();
+    }
+}

packages/pyright-internal/src/analyzer/typeEvaluator.ts

@@ -106,6 +106,7 @@ import {
     isPossibleTypeAliasDeclaration,
 } from './declarationUtils';
 import { applyFunctionTransform } from './functionTransform';
+import { maybeAddMicrobitVersionWarning } from './microbitUtils';
 import { createNamedTupleType } from './namedTuples';
 import * as ParseTreeUtils from './parseTreeUtils';
 import { assignTypeToPatternTargets, narrowTypeBasedOnPattern } from './patternMatching';
@@ -3854,6 +3855,10 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
             type = validateTypeVarUsage(node, type, flags);
         }
 
+        // Maybe add warning diagnostic for V2 micro:bit module members
+        // (functions) where these are imported.
+        maybeAddMicrobitVersionWarning(type, node, addDiagnostic);
+
         return { type, node, isIncomplete };
     }
 
@@ -4526,6 +4531,12 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                         isAsymmetricDescriptor = true;
                     }
                 }
+
+                if (type) {
+                    // Maybe add warning diagnostic for V2 micro:bit class methods.
+                    maybeAddMicrobitVersionWarning(type, node, addDiagnostic);
+                }
+
                 break;
             }
 
@@ -4614,6 +4625,9 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                         type = evaluatorOptions.evaluateUnknownImportsAsAny ? AnyType.create() : UnknownType.create();
                     }
                 }
+
+                // Maybe add warning diagnostic for V2 micro:bit modules or module members.
+                maybeAddMicrobitVersionWarning(type, node, addDiagnostic, memberName);
                 break;
             }
 
@@ -16203,6 +16217,10 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
             }
         }
 
+        // Maybe add warning diagnostic for V2 micro:bit module
+        // members for `from module import member`.
+        maybeAddMicrobitVersionWarning(symbolType, node.name, addDiagnostic);
+
         assignTypeToNameNode(aliasNode, symbolType, /* isIncomplete */ false);
         writeTypeCache(node, symbolType, EvaluatorFlags.None, /* isIncomplete */ false);
     }

packages/pyright-internal/src/common/configOptions.ts

@@ -285,6 +285,9 @@ export interface DiagnosticRuleSet {
     // Report cases where the a "match" statement is not exhaustive in
     // covering all possible cases.
     reportMatchNotExhaustive: DiagnosticLevel;
+
+    // Report micro:bit V2 API use.
+    reportMicrobitV2ApiUse: DiagnosticLevel;
 }
 
 export function cloneDiagnosticRuleSet(diagSettings: DiagnosticRuleSet): DiagnosticRuleSet {
@@ -374,6 +377,7 @@ export function getDiagLevelDiagnosticRules() {
         DiagnosticRule.reportUnusedCoroutine,
         DiagnosticRule.reportUnnecessaryTypeIgnoreComment,
         DiagnosticRule.reportMatchNotExhaustive,
+        DiagnosticRule.reportMicrobitV2ApiUse,
     ];
 }
 
@@ -453,6 +457,7 @@ export function getOffDiagnosticRuleSet(): DiagnosticRuleSet {
         reportUnusedCoroutine: 'none',
         reportUnnecessaryTypeIgnoreComment: 'none',
         reportMatchNotExhaustive: 'none',
+        reportMicrobitV2ApiUse: 'none',
     };
 
     return diagSettings;
@@ -528,6 +533,7 @@ export function getBasicDiagnosticRuleSet(): DiagnosticRuleSet {
         reportUnusedCoroutine: 'error',
         reportUnnecessaryTypeIgnoreComment: 'none',
         reportMatchNotExhaustive: 'none',
+        reportMicrobitV2ApiUse: 'warning',
     };
 
     return diagSettings;
@@ -603,6 +609,7 @@ export function getStrictDiagnosticRuleSet(): DiagnosticRuleSet {
         reportUnusedCoroutine: 'error',
         reportUnnecessaryTypeIgnoreComment: 'none',
         reportMatchNotExhaustive: 'error',
+        reportMicrobitV2ApiUse: 'warning',
     };
 
     return diagSettings;

packages/pyright-internal/src/common/diagnosticRules.ts

@@ -75,4 +75,6 @@ export enum DiagnosticRule {
     reportUnusedCoroutine = 'reportUnusedCoroutine',
     reportUnnecessaryTypeIgnoreComment = 'reportUnnecessaryTypeIgnoreComment',
     reportMatchNotExhaustive = 'reportMatchNotExhaustive',
+
+    reportMicrobitV2ApiUse = 'reportMicrobitV2ApiUse',
 }

packages/pyright-internal/src/localization/localize.ts

@@ -521,6 +521,18 @@ export namespace Localizer {
             );
         export const methodReturnsNonObject = () =>
             new ParameterizedString<{ name: string }>(getRawString('Diagnostic.methodReturnsNonObject'));
+        export const microbitV2ClassMethodUse = () =>
+            new ParameterizedString<{ methodName: string; className: string; device: string }>(
+                getRawString('Diagnostic.microbitV2ClassMethodUse')
+            );
+        export const microbitV2ModuleMemberUse = () =>
+            new ParameterizedString<{ name: string; moduleName: string; device: string }>(
+                getRawString('Diagnostic.microbitV2ModuleMemberUse')
+            );
+        export const microbitV2ModuleUse = () =>
+            new ParameterizedString<{ moduleName: string; device: string }>(
+                getRawString('Diagnostic.microbitV2ModuleUse')
+            );
         export const missingProtocolMembers = () => getRawString('Diagnostic.missingProtocolMembers');
         export const missingSuperCall = () =>
             new ParameterizedString<{ methodName: string }>(getRawString('Diagnostic.missingSuperCall'));

packages/pyright-internal/src/localization/simplified.nls.en-us.json

@@ -58,6 +58,9 @@
         "memberSet": "Cannot assign member \"{name}\" for type \"{type}\"",
         "moduleNotCallable": "Module is not callable",
         "moduleUnknownMember": "\"{name}\" is not a known member of module \"{module}\"",
+        "microbitV2ClassMethodUse": "The \"{methodName}\" method on the \"{className}\" class cannot be used with a {device}",
+        "microbitV2ModuleMemberUse": "\"{name}\" from the \"{moduleName}\" module cannot be used with a {device}",
+        "microbitV2ModuleUse": "\"{moduleName}\" cannot be used with a {device}",
         "nonDefaultAfterDefault": "Non-default argument follows default argument",
         "noOverload": "Arguments do not match parameter types",
         "objectNotCallable": "Object is not callable",