*/

function checkClassPropertyAccess(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, type: Type, prop: Symbol): boolean {

let flags = getDeclarationFlagsFromSymbol(prop);

if (left.kind === SyntaxKind.SuperKeyword) {

let errorNode = (<PropertyAccessExpression>node).name ?

// cannot simultaneously be private and abstract, so this will trigger an

// additional error elsewhere.

error(errorNode, Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(declaringClass));

return false;

}

let enclosingClassDeclaration = getContainingClass(node);

let enclosingClass = enclosingClassDeclaration ? <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined;

// Private property is accessible if declaring and enclosing class are the same

if (flags & NodeFlags.Private) {

let expressionType = checkExpression(node.expression);

// more construct signatures, the expression is processed in the same manner as a

// function call, but using the construct signatures as the initial set of candidate

// signatures for overload resolution. The result type of the function call becomes

return resolveErrorCall(node);

}

// Note, only class declarations can be declared abstract.

// In the case of a merged class-module or class-interface declaration,

// only the class declaration node will have the Abstract flag set.

}

// TS 1.0 spec: 4.11

// list and the result of the operation is of type Any.

if (isTypeAny(expressionType)) {

if (node.typeArguments) {

return resolveCall(node, constructSignatures, candidatesOutArray);

}

// one or more call signatures, the expression is processed as a function call. A compile-time

// error occurs if the result of the function call is not Void. The type of the result of the

// operation is Any.

return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");

}

}

flags |= NodeFlags.Abstract;

break;