Mar 25, 2021 · Jan 15, 2021 · Jan 15, 2021 · Jan 18, 2021 · Jan 19, 2021 · Jan 25, 2021
diff --git a/src/compiler/factory/emitHelpers.ts b/src/compiler/factory/emitHelpers.ts
        createClassPrivateFieldSetHelper(receiver: Expression, privateField: Identifier, value: Expression): Expression;
        createClassPrivateMethodGetHelper(receiver: Expression, instances: Identifier, fn: Identifier): Expression;
        createClassPrivateReadonlyHelper(receiver: Expression, value: Expression): Expression;
        createClassPrivateAccessorGetHelper(receiver: Expression, instances: Identifier, fn: Identifier): Expression;
        createClassPrivateAccessorSetHelper(receiver: Expression, instances: Identifier, fn: Identifier, value: Expression): Expression;
    }

    export function createEmitHelperFactory(context: TransformationContext): EmitHelperFactory {
            createClassPrivateFieldSetHelper,
            createClassPrivateMethodGetHelper,
            createClassPrivateReadonlyHelper,
            createClassPrivateAccessorGetHelper,
            createClassPrivateAccessorSetHelper,
        };

        /**
            return factory.createCallExpression(getUnscopedHelperName("__classPrivateReadonly"), /*typeArguments*/ undefined, [receiver, value]);
        }

        function createClassPrivateAccessorGetHelper(receiver: Expression, instances: Identifier, fn: Identifier) {
            context.requestEmitHelper(classPrivateAccessorGetHelper);
            return factory.createCallExpression(getUnscopedHelperName("__classPrivateAccessorGet"), /*typeArguments*/ undefined, [receiver, instances, fn]);
        }

        function createClassPrivateAccessorSetHelper(receiver: Expression, instances: Identifier, fn: Identifier, value: Expression) {
            context.requestEmitHelper(classPrivateAccessorSetHelper);
            return factory.createCallExpression(getUnscopedHelperName("__classPrivateAccessorSet"), /*typeArguments*/ undefined, [receiver, instances, fn, value]);
        }
    }

    /* @internal */
            };`
    };

    export const classPrivateAccessorGetHelper: UnscopedEmitHelper = {
        name: "typescript:classPrivateAccessorGet",
        importName: "__classPrivateAccessorGet",
        scoped: false,
        text: `
            var __classPrivateAccessorGet = (this && this.__classPrivateAccessorGet) || function (receiver, instances, fn) {
                if (!instances.has(receiver)) {
                    throw new TypeError("attempted to get private accessor on non-instance");
                }
                return fn.call(receiver);
            };`
    };

    export const classPrivateAccessorSetHelper: UnscopedEmitHelper = {
        name: "typescript:classPrivateAccessorSet",
        importName: "__classPrivateAccessorSet",
        scoped: false,
        text: `
            var __classPrivateAccessorSet = (this && this.__classPrivateAccessorSet) || function (receiver, instances, fn, value) {
                if (!instances.has(receiver)) {
                    throw new TypeError("attempted to set private accessor on non-instance");
                }
                return fn.call(receiver, value);
            };`
    };

    let allUnscopedEmitHelpers: ReadonlyESMap<string, UnscopedEmitHelper> | undefined;

    export function getAllUnscopedEmitHelpers() {
            classPrivateFieldSetHelper,
            classPrivateMethodGetHelper,
            classPrivateReadonlyHelper,
            classPrivateAccessorGetHelper,
            classPrivateAccessorSetHelper,
            createBindingHelper,
            setModuleDefaultHelper
        ], helper => helper.name));
diff --git a/src/compiler/transformers/classFields.ts b/src/compiler/transformers/classFields.ts
    const enum PrivateIdentifierPlacement {
        InstanceField,
        InstanceMethod,
        InstanceAccessor
    }

    type PrivateIdentifierInfo =
        | PrivateIdentifierInstanceField
        | PrivateIdentifierInstanceMethod;
        | PrivateIdentifierInstanceMethod
        | PrivateIdentifierInstanceAccessor;

    interface PrivateIdentifierInstanceField {
        placement: PrivateIdentifierPlacement.InstanceField;
        functionName: Identifier;
    }

    interface PrivateIdentifierInstanceAccessor {
        placement: PrivateIdentifierPlacement.InstanceAccessor;
        getterName?: Identifier;
        setterName?: Identifier;
    }

    interface PrivateIdentifierEnvironment {
        /**
         * Used for prefixing generated variable names.

                case SyntaxKind.GetAccessor:
                case SyntaxKind.SetAccessor:
                    // Visit the name of the member (if it's a computed property name).
                    return visitEachChild(node, classElementVisitor, context);
                    return visitMethodDeclaration(node as AccessorDeclaration);

                case SyntaxKind.MethodDeclaration:
                    return visitMethodDeclaration(node as MethodDeclaration);
            return node;
        }

        function visitMethodDeclaration(node: MethodDeclaration) {
        function visitMethodDeclaration(node: MethodDeclaration | AccessorDeclaration) {
            Debug.assert(!some(node.decorators));
            const transformedMethod = visitEachChild(node, classElementVisitor, context);

            return undefined;
        }

        function getHoistedFunctionName(node: MethodDeclaration) {
        function getHoistedFunctionName(node: MethodDeclaration | AccessorDeclaration) {
            Debug.assert(isPrivateIdentifier(node.name));
            const privateIdentifierInfo = accessPrivateIdentifier(node.name);
            Debug.assert(privateIdentifierInfo, "Undeclared private name for property declaration.");
                return privateIdentifierInfo.functionName;
            }

            if (privateIdentifierInfo.placement === PrivateIdentifierPlacement.InstanceAccessor) {
                if (isGetAccessor(node)) {
                    Debug.assert(privateIdentifierInfo.getterName);
                    return privateIdentifierInfo.getterName;
                }
                if (isSetAccessor(node)) {
                    Debug.assert(privateIdentifierInfo.setterName);
                    return privateIdentifierInfo.setterName;
                }
            }

            Debug.fail("Unexpected private identifier placement");
        }

                        getPrivateIdentifierEnvironment().weakSetName,
                        info.functionName
                    );
                case PrivateIdentifierPlacement.InstanceAccessor: {
                    return context.getEmitHelperFactory().createClassPrivateAccessorGetHelper(
                        receiver,
                        getPrivateIdentifierEnvironment().weakSetName,
                        info.getterName! // TODO: TypeError is missing
                    );
                }
                default: return Debug.fail("Unexpected private identifier placement");
            }
        }
                        receiver,
                        right
                    );
                case PrivateIdentifierPlacement.InstanceAccessor:
                    return context.getEmitHelperFactory().createClassPrivateAccessorSetHelper(
                        receiver,
                        getPrivateIdentifierEnvironment().weakSetName,
                        info.setterName!, // TODO: TypeError if missing
                        right
                    );
                default: return Debug.fail("Unexpected private identifier placement");
            }
        }
                properties = filter(properties, property => !!property.initializer || isPrivateIdentifier(property.name));
            }

            const privateMethods = filter(getMethods(node, /*isStatic*/ false), method => isPrivateIdentifier(method.name));
            const privateMethods = filter(
                [...getMethods(node, /*isStatic*/ false), ...getAccessors(node, /*isStatic*/ false)],
                method => isPrivateIdentifier(method.name)
            );
            const needsConstructorBody = some(properties) || some(privateMethods);

            // Only generate synthetic constructor when there are property initializers to move.
         * @param methods An array of method declarations.
         * @param receiver The receiver on which each method should be assigned.
         */
        function addMethodStatements(statements: Statement[], methods: readonly (MethodDeclaration)[], receiver: LeftHandSideExpression) {
        function addMethodStatements(statements: Statement[], methods: readonly (MethodDeclaration | AccessorDeclaration)[], receiver: LeftHandSideExpression) {
            if (!shouldTransformPrivateElements || !some(methods)) {
                return;
            }

        function addPrivateIdentifierToEnvironment(node: PrivateClassElementDeclaration) {
            const text = getTextOfPropertyName(node.name) as string;
            const uniqueVariableName = createHoistedVariableForPrivateName(text);
            let info: PrivateIdentifierInfo;
            const assignmentExpressions: Expression[] = [];

            if (isPropertyDeclaration(node)) {
                const weakMapName = createHoistedVariableForPrivateName(text);
                info = {
                    placement: PrivateIdentifierPlacement.InstanceField,
                    weakMapName: uniqueVariableName
                    weakMapName,
                };

                assignmentExpressions.push(factory.createAssignment(
 uniqueVariableName,
 weakMapName,
                    factory.createNewExpression(
                        factory.createIdentifier("WeakMap"),
                        /*typeArguments*/ undefined,
            else if (isMethodDeclaration(node)) {
                info = {
                    placement: PrivateIdentifierPlacement.InstanceMethod,
                    functionName:uniqueVariableName
                    functionName:createHoistedVariableForPrivateName(text)
                };

                getPrivateIdentifierEnvironment().hasPrivateMethods = true;
            }
            else if (isAccessor(node)) {
                const previousInfo = findPreviousAccessorInfo(node);
                info = {
                    ...previousInfo,
                    placement: PrivateIdentifierPlacement.InstanceAccessor,
                };

                if (isGetAccessor(node)) {
                    info.getterName = createHoistedVariableForPrivateName(text + "_get");
                }
                else {
                    info.setterName = createHoistedVariableForPrivateName(text + "_set");;
                }

                getPrivateIdentifierEnvironment().hasPrivateMethods = true;
            }
            else {
                return;
            }
            getPendingExpressions().push(...assignmentExpressions);
        }

        function findPreviousAccessorInfo(node: PrivateIdentifierGetAccessorDeclaration | PrivateIdentifierSetAccessorDeclaration): PrivateIdentifierInstanceAccessor | undefined {
            const info = getPrivateIdentifierEnvironment().identifiers.get(node.name.escapedText);
            if (info && info.placement === PrivateIdentifierPlacement.InstanceAccessor) {
                return info;
            }
        }

        function createHoistedVariableForClass(name: string): Identifier {
            const { className } = getPrivateIdentifierEnvironment();
            const prefix = className ? `_${className}` : "";
diff --git a/src/compiler/transformers/utilities.ts b/src/compiler/transformers/utilities.ts
     * Gets all the static or all the instance method declarations of a class.
     *
     * @param node The class node.
     * @param isStatic A value indicating whether to getproperties from the static or instance side of the class.
     * @param isStatic A value indicating whether to getmethods from the static or instance side of the class.
     */
    export function getMethods(node: ClassExpression | ClassDeclaration, isStatic: boolean): readonly MethodDeclaration[] {
        return filter(node.members, m => isStaticMethodDeclaration(m, isStatic)) as MethodDeclaration[];
    }

    /**
     * Gets all the static or all the instance accessor declarations of a class.
     *
     * @param node The class node.
     * @param isStatic A value indicating whether to get accessors from the static or instance side of the class.
     */
    export function getAccessors(node: ClassExpression | ClassDeclaration, isStatic: boolean): readonly AccessorDeclaration[] {
        return filter(node.members, m => isStaticAccessorDeclaration(m, isStatic)) as AccessorDeclaration[];
    }

    /**
     * Is a class element either a static or an instance property declaration with an initializer?
     *
        return isMethodDeclaration(member) && hasStaticModifier(member) === isStatic;
    }

    /**
     * Gets a value indicating whether a class element is either a static or an instance accessor declaration.
     *
     * @param member The class element node.
     * @param isStatic A value indicating whether the member should be a static or instance member.
     */
    export function isStaticAccessorDeclaration(member: ClassElement, isStatic: boolean): member is AccessorDeclaration {
        return isGetOrSetAccessorDeclaration(member) && hasStaticModifier(member) === isStatic;
    }
 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -36,6 +36,8 @@ namespace ts {
		createClassPrivateFieldSetHelper(receiver: Expression, privateField: Identifier, value: Expression): Expression;
		createClassPrivateMethodGetHelper(receiver: Expression, instances: Identifier, fn: Identifier): Expression;
		createClassPrivateReadonlyHelper(receiver: Expression, value: Expression): Expression;
		createClassPrivateAccessorGetHelper(receiver: Expression, instances: Identifier, fn: Identifier): Expression;
		createClassPrivateAccessorSetHelper(receiver: Expression, instances: Identifier, fn: Identifier, value: Expression): Expression;
		}

		export function createEmitHelperFactory(context: TransformationContext): EmitHelperFactory {
Expand DownExpand Up		@@ -76,6 +78,8 @@ namespace ts {
		createClassPrivateFieldSetHelper,
		createClassPrivateMethodGetHelper,
		createClassPrivateReadonlyHelper,
		createClassPrivateAccessorGetHelper,
		createClassPrivateAccessorSetHelper,
		};

		/**
Expand DownExpand Up		@@ -392,6 +396,15 @@ namespace ts {
		return factory.createCallExpression(getUnscopedHelperName("__classPrivateReadonly"), /typeArguments/ undefined, [receiver, value]);
		}

		function createClassPrivateAccessorGetHelper(receiver: Expression, instances: Identifier, fn: Identifier) {
		context.requestEmitHelper(classPrivateAccessorGetHelper);
		return factory.createCallExpression(getUnscopedHelperName("__classPrivateAccessorGet"), /typeArguments/ undefined, [receiver, instances, fn]);
		}

		function createClassPrivateAccessorSetHelper(receiver: Expression, instances: Identifier, fn: Identifier, value: Expression) {
		context.requestEmitHelper(classPrivateAccessorSetHelper);
		return factory.createCallExpression(getUnscopedHelperName("__classPrivateAccessorSet"), /typeArguments/ undefined, [receiver, instances, fn, value]);
		}
		}

		/* @internal */
Expand DownExpand Up		@@ -882,6 +895,32 @@ namespace ts {
		};`
		};

		export const classPrivateAccessorGetHelper: UnscopedEmitHelper = {
		name: "typescript:classPrivateAccessorGet",
		importName: "__classPrivateAccessorGet",
		scoped: false,
		text: `
		var __classPrivateAccessorGet = (this && this.__classPrivateAccessorGet) \|\| function (receiver, instances, fn) {
		if (!instances.has(receiver)) {
		throw new TypeError("attempted to get private accessor on non-instance");
		}
		return fn.call(receiver);
		};`
		};

		export const classPrivateAccessorSetHelper: UnscopedEmitHelper = {
		name: "typescript:classPrivateAccessorSet",
		importName: "__classPrivateAccessorSet",
		scoped: false,
		text: `
		var __classPrivateAccessorSet = (this && this.__classPrivateAccessorSet) \|\| function (receiver, instances, fn, value) {
		if (!instances.has(receiver)) {
		throw new TypeError("attempted to set private accessor on non-instance");
		}
		return fn.call(receiver, value);
		};`
		};

		let allUnscopedEmitHelpers: ReadonlyESMap<string, UnscopedEmitHelper> \| undefined;

		export function getAllUnscopedEmitHelpers() {
Expand DownExpand Up		@@ -909,6 +948,8 @@ namespace ts {
		classPrivateFieldSetHelper,
		classPrivateMethodGetHelper,
		classPrivateReadonlyHelper,
		classPrivateAccessorGetHelper,
		classPrivateAccessorSetHelper,
		createBindingHelper,
		setModuleDefaultHelper
		], helper => helper.name));
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -11,11 +11,13 @@ namespace ts {
		const enum PrivateIdentifierPlacement {
		InstanceField,
		InstanceMethod,
		InstanceAccessor
		}

		type PrivateIdentifierInfo =
		\| PrivateIdentifierInstanceField
		\| PrivateIdentifierInstanceMethod;
		\| PrivateIdentifierInstanceMethod
		\| PrivateIdentifierInstanceAccessor;

		interface PrivateIdentifierInstanceField {
		placement: PrivateIdentifierPlacement.InstanceField;
Expand All		@@ -27,6 +29,12 @@ namespace ts {
		functionName: Identifier;
		}

		interface PrivateIdentifierInstanceAccessor {
		placement: PrivateIdentifierPlacement.InstanceAccessor;
		getterName?: Identifier;
		setterName?: Identifier;
		}

		interface PrivateIdentifierEnvironment {
		/**
		* Used for prefixing generated variable names.
Expand DownExpand Up		@@ -166,8 +174,7 @@ namespace ts {

		case SyntaxKind.GetAccessor:
		case SyntaxKind.SetAccessor:
		// Visit the name of the member (if it's a computed property name).
		return visitEachChild(node, classElementVisitor, context);
		return visitMethodDeclaration(node as AccessorDeclaration);

		case SyntaxKind.MethodDeclaration:
		return visitMethodDeclaration(node as MethodDeclaration);
Expand DownExpand Up		@@ -213,7 +220,7 @@ namespace ts {
		return node;
		}

		function visitMethodDeclaration(node: MethodDeclaration) {
		function visitMethodDeclaration(node: MethodDeclaration \| AccessorDeclaration) {
dragomirtitian marked this conversation as resolved. OutdatedShow resolvedHide resolved
		Debug.assert(!some(node.decorators));
		const transformedMethod = visitEachChild(node, classElementVisitor, context);
Copy link Contributor rbucktonMar 15, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. I'd rather the call to`visitEachChild` happens inside the`if` clause below, and that we invoke the visitor for each element in the`if (functionName)` case below. It saves us from allocating a node that we will just toss away in the private method/accessor case. mkubilayk reacted with thumbs up emoji

Expand DownExpand Up		@@ -241,7 +248,7 @@ namespace ts {
		return undefined;
		}

		function getHoistedFunctionName(node: MethodDeclaration) {
		function getHoistedFunctionName(node: MethodDeclaration \| AccessorDeclaration) {
		Debug.assert(isPrivateIdentifier(node.name));
		const privateIdentifierInfo = accessPrivateIdentifier(node.name);
		Debug.assert(privateIdentifierInfo, "Undeclared private name for property declaration.");
Expand All		@@ -250,6 +257,17 @@ namespace ts {
		return privateIdentifierInfo.functionName;
		}

		if (privateIdentifierInfo.placement === PrivateIdentifierPlacement.InstanceAccessor) {
		if (isGetAccessor(node)) {
		Debug.assert(privateIdentifierInfo.getterName);
		return privateIdentifierInfo.getterName;
		}
		if (isSetAccessor(node)) {
		Debug.assert(privateIdentifierInfo.setterName);
		return privateIdentifierInfo.setterName;
		}
		}

		Debug.fail("Unexpected private identifier placement");
		}

Expand DownExpand Up		@@ -296,6 +314,13 @@ namespace ts {
		getPrivateIdentifierEnvironment().weakSetName,
		info.functionName
		);
		case PrivateIdentifierPlacement.InstanceAccessor: {
		return context.getEmitHelperFactory().createClassPrivateAccessorGetHelper(
		receiver,
		getPrivateIdentifierEnvironment().weakSetName,
		info.getterName! // TODO: TypeError is missing
		);
		}
		default: return Debug.fail("Unexpected private identifier placement");
		}
		}
Expand DownExpand Up		@@ -502,6 +527,13 @@ namespace ts {
		receiver,
		right
		);
		case PrivateIdentifierPlacement.InstanceAccessor:
		return context.getEmitHelperFactory().createClassPrivateAccessorSetHelper(
		receiver,
		getPrivateIdentifierEnvironment().weakSetName,
		info.setterName!, // TODO: TypeError if missing
		right
		);
		default: return Debug.fail("Unexpected private identifier placement");
		}
		}
Expand DownExpand Up		@@ -732,7 +764,10 @@ namespace ts {
		properties = filter(properties, property => !!property.initializer \|\| isPrivateIdentifier(property.name));
		}

		const privateMethods = filter(getMethods(node, /isStatic/ false), method => isPrivateIdentifier(method.name));
		const privateMethods = filter(
		[...getMethods(node, /isStatic/ false), ...getAccessors(node, /isStatic/ false)],
		method => isPrivateIdentifier(method.name)
		);
		const needsConstructorBody = some(properties) \|\| some(privateMethods);

		// Only generate synthetic constructor when there are property initializers to move.
Expand DownExpand Up		@@ -928,7 +963,7 @@ namespace ts {
		* @param methods An array of method declarations.
		* @param receiver The receiver on which each method should be assigned.
		*/
		function addMethodStatements(statements: Statement[], methods: readonly (MethodDeclaration)[], receiver: LeftHandSideExpression) {
		function addMethodStatements(statements: Statement[], methods: readonly (MethodDeclaration \| AccessorDeclaration)[], receiver: LeftHandSideExpression) {
		if (!shouldTransformPrivateElements \|\| !some(methods)) {
		return;
		}
Expand DownExpand Up		@@ -1039,18 +1074,18 @@ namespace ts {

		function addPrivateIdentifierToEnvironment(node: PrivateClassElementDeclaration) {
		const text = getTextOfPropertyName(node.name) as string;
		const uniqueVariableName = createHoistedVariableForPrivateName(text);
		let info: PrivateIdentifierInfo;
		const assignmentExpressions: Expression[] = [];

		if (isPropertyDeclaration(node)) {
		const weakMapName = createHoistedVariableForPrivateName(text);
		info = {
		placement: PrivateIdentifierPlacement.InstanceField,
		weakMapName: uniqueVariableName
		weakMapName,
		};

		assignmentExpressions.push(factory.createAssignment(
		uniqueVariableName,
		weakMapName,
		factory.createNewExpression(
		factory.createIdentifier("WeakMap"),
		/typeArguments/ undefined,
Expand All		@@ -1061,11 +1096,27 @@ namespace ts {
		else if (isMethodDeclaration(node)) {
		info = {
		placement: PrivateIdentifierPlacement.InstanceMethod,
		functionName:uniqueVariableName
		functionName:createHoistedVariableForPrivateName(text)
		};

		getPrivateIdentifierEnvironment().hasPrivateMethods = true;
		}
		else if (isAccessor(node)) {
		const previousInfo = findPreviousAccessorInfo(node);
		info = {
		...previousInfo,
		placement: PrivateIdentifierPlacement.InstanceAccessor,
		};

		if (isGetAccessor(node)) {
		info.getterName = createHoistedVariableForPrivateName(text + "_get");
		}
		else {
		info.setterName = createHoistedVariableForPrivateName(text + "_set");;
		}

		getPrivateIdentifierEnvironment().hasPrivateMethods = true;
		}
		else {
		return;
		}
Expand All		@@ -1074,6 +1125,13 @@ namespace ts {
		getPendingExpressions().push(...assignmentExpressions);
		}

		function findPreviousAccessorInfo(node: PrivateIdentifierGetAccessorDeclaration \| PrivateIdentifierSetAccessorDeclaration): PrivateIdentifierInstanceAccessor \| undefined {
		const info = getPrivateIdentifierEnvironment().identifiers.get(node.name.escapedText);
		if (info && info.placement === PrivateIdentifierPlacement.InstanceAccessor) {
		return info;
		}
		}

		function createHoistedVariableForClass(name: string): Identifier {
		const { className } = getPrivateIdentifierEnvironment();
		const prefix = className ? `_${className}` : "";
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -347,12 +347,22 @@ namespace ts {
		* Gets all the static or all the instance method declarations of a class.
		*
		* @param node The class node.
		* @param isStatic A value indicating whether to getproperties from the static or instance side of the class.
		* @param isStatic A value indicating whether to getmethods from the static or instance side of the class.
		*/
		export function getMethods(node: ClassExpression \| ClassDeclaration, isStatic: boolean): readonly MethodDeclaration[] {
Copy link Contributor rbucktonMar 15, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Is this used anywhere else outside of the classFields transform? The one place it seems to be used would be better suited to have the filter moved into it instead. The same comment applies to`getAccessors`, below. mkubilayk reacted with thumbs up emoji
		return filter(node.members, m => isStaticMethodDeclaration(m, isStatic)) as MethodDeclaration[];
		}

		/**
		* Gets all the static or all the instance accessor declarations of a class.
		*
		* @param node The class node.
		* @param isStatic A value indicating whether to get accessors from the static or instance side of the class.
		*/
		export function getAccessors(node: ClassExpression \| ClassDeclaration, isStatic: boolean): readonly AccessorDeclaration[] {
		return filter(node.members, m => isStaticAccessorDeclaration(m, isStatic)) as AccessorDeclaration[];
		}

		/**
		* Is a class element either a static or an instance property declaration with an initializer?
		*
Expand DownExpand Up		@@ -386,4 +396,13 @@ namespace ts {
		return isMethodDeclaration(member) && hasStaticModifier(member) === isStatic;
		}

		/**
		* Gets a value indicating whether a class element is either a static or an instance accessor declaration.
		*
		* @param member The class element node.
		* @param isStatic A value indicating whether the member should be a static or instance member.
		*/
		export function isStaticAccessorDeclaration(member: ClassElement, isStatic: boolean): member is AccessorDeclaration {
		return isGetOrSetAccessorDeclaration(member) && hasStaticModifier(member) === isStatic;
		}
		}