ForStatement = 1 << 10, // Enclosing block-scoped container is a ForStatement

ForInOrForOfStatement = 1 << 11, // Enclosing block-scoped container is a ForInStatement or ForOfStatement

ConstructorWithCapturedSuper = 1 << 12, // Enclosed in a constructor that captures 'this' for use with 'super'

// NOTE: do not add more ancestor flags without also updating AncestorFactsMask below.

// NOTE: when adding a new ancestor flag, be sure to update the subtree flags below.

//

// Ancestor masks

//

// We are always in *some* kind of block scope, but only specific block-scope containers are

// top-level or Blocks.

// Functions, methods, and accessors are both new lexical scopes and new block scopes.

FunctionIncludes = Function | TopLevel,

AsyncFunctionBodyIncludes = FunctionIncludes | AsyncFunctionBody,

AsyncFunctionBodyExcludes = FunctionExcludes & ~NonStaticClassElement,

// Arrow functions are lexically scoped to their container, but are new block scopes.

ArrowFunctionIncludes = ArrowFunction | TopLevel,

// Constructors are both new lexical scopes and new block scopes. Constructors are also

// always considered non-static members of a class.

IterationStatementBlockIncludes = IterationStatementBlock,

IterationStatementBlockExcludes = BlockScopeExcludes,

//

// Subtree facts

//

//

// Subtree masks

//

SubtreeFactsMask = ~AncestorFactsMask,

}

export function transformES2015(context: TransformationContext) {

}

function visitThisKeyword(node: Node): Node {

if (convertedLoopState) {

if (hierarchyFacts & HierarchyFacts.ArrowFunction) {

// if the enclosing function is an ArrowFunction then we use the captured 'this' keyword.

}

statements.push(constructorFunction);

convertedLoopState = savedConvertedLoopState;

}

function transformClassMethodDeclarationToStatement(receiver: LeftHandSideExpression, member: MethodDeclaration, container: Node) {

const commentRange = getCommentRange(member);

const sourceMapRange = getSourceMapRange(member);

const memberName = createMemberAccessForPropertyName(receiver, visitNode(member.name, visitor, isPropertyName), /*location*/ member.name);

// No source map should be emitted for this statement to align with the

// old emitter.

setEmitFlags(statement, EmitFlags.NoSourceMap);

return statement;

}

function transformAccessorsToExpression(receiver: LeftHandSideExpression, { firstAccessor, getAccessor, setAccessor }: AllAccessorDeclarations, container: Node, startsOnNewLine: boolean): Expression {

// To align with source maps in the old emitter, the receiver and property name

// arguments are both mapped contiguously to the accessor name.

const target = getMutableClone(receiver);

startOnNewLine(call);

}

return call;

}

? getLocalName(node)

: node.name;

convertedLoopState = savedConvertedLoopState;

return updateFunctionExpression(

node,

? getLocalName(node)

: node.name;

convertedLoopState = savedConvertedLoopState;

return updateFunctionDeclaration(

node,

name = getGeneratedNameForNode(node);

}

convertedLoopState = savedConvertedLoopState;

return setOriginalNode(

setTextRange(

function transformObjectLiteralMethodDeclarationToExpression(method: MethodDeclaration, receiver: Expression, container: Node, startsOnNewLine: boolean) {

const expression = createAssignment(

createMemberAccessForPropertyName(

receiver,

if (startsOnNewLine) {

startOnNewLine(expression);

}

return expression;

}

else {

updated = updateSetAccessor(node, node.decorators, node.modifiers, node.name, parameters, body);

}

convertedLoopState = savedConvertedLoopState;

return updated;

}

}

function visitComputedPropertyName(node: ComputedPropertyName) {

}

/**

function visitMetaProperty(node: MetaProperty) {

if (node.keywordToken === SyntaxKind.NewKeyword && node.name.escapedText === "target") {

return createFileLevelUniqueName("_newTarget");

}

return node;