public override PhpTypeCode Emit(InstanceOfEx node, CodeGenerator codeGenerator)
{
Statistics.AST.AddNode("InstanceOfEx");
// emits load of expression value on the stack:
codeGenerator.EmitBoxing(node.Expression.Emit(codeGenerator));
var resolvedType = TypeRefHelper.ResolvedType(node.ClassNameRef);
if (resolvedType != null && typeArgsResolved)
{
// type is resolvable (doesn't mean known) //
resolvedType.EmitInstanceOf(codeGenerator, null);
}
else
{
// type is unresolvable (there is some variable or the type is a generic parameter) //
codeGenerator.EmitInstanceOfOperator(null, node.ClassNameRef, null);
}
if (access == AccessType.None)
{
codeGenerator.IL.Emit(OpCodes.Pop);
return(PhpTypeCode.Void);
}
else
{
return(PhpTypeCode.Boolean);
}
}
public override PhpTypeCode Emit(TypeOfEx node, CodeGenerator codeGenerator)
{
Statistics.AST.AddNode("TypeOfEx");
var resolvedtype = TypeRefHelper.ResolvedType(node.ClassNameRef);
if (resolvedtype != null && typeArgsResolved)
{
// type is resolvable (doesn't mean known) //
resolvedtype.EmitTypeOf(codeGenerator, null);
}
else
{
// type is unresolvable (there is some variable or the type is a generic parameter) //
codeGenerator.EmitTypeOfOperator(null, node.ClassNameRef, null);
}
if (access == AccessType.None)
{
codeGenerator.IL.Emit(OpCodes.Pop);
return(PhpTypeCode.Void);
}
else
{
return(PhpTypeCode.DObject);
}
}
internal override bool Analyze(DirectTypeRef node, Analyzer analyzer)
{
resolvedType = analyzer.ResolveTypeName(node.ClassName, analyzer.CurrentType, analyzer.CurrentRoutine, node.Span, false);
// base call must follow the class name resolution:
bool args_static = base.Analyze(node, analyzer);
if (args_static)
{
DTypeDesc[] resolved_arguments = DTypeDesc.EmptyArray;
var genericParams = node.GenericParams;
if (genericParams != null && genericParams.Count > 0)
{
resolved_arguments = new DTypeDesc[genericParams.Count];
for (int i = 0; i < genericParams.Count; i++)
{
resolved_arguments[i] = TypeRefHelper.ResolvedType(genericParams[i]).TypeDesc;
}
}
resolvedType = resolvedType.MakeConstructedType(analyzer, resolved_arguments, node.Span);
}
return(args_static);
}
public override Evaluation Analyze(NewEx node, Analyzer analyzer, ExInfoFromParent info)
{
Debug.Assert(node.IsMemberOf == null);
access = info.Access;
this.typeArgsResolved = TypeRefHelper.Analyze(node.ClassNameRef, analyzer);
DType type = TypeRefHelper.ResolvedType(node.ClassNameRef);
RoutineSignature signature;
if (typeArgsResolved)
{
analyzer.AnalyzeConstructedType(type);
}
if (type != null)
{
bool error_reported = false;
// make checks if we are sure about character of the type:
if (type.IsIdentityDefinite)
{
if (type.IsAbstract || type.IsInterface)
{
analyzer.ErrorSink.Add(Errors.AbstractClassOrInterfaceInstantiated, analyzer.SourceUnit,
node.Span, type.FullName);
error_reported = true;
}
}
// disallow instantiation of Closure
if (type.RealType == typeof(PHP.Library.SPL.Closure))
{
analyzer.ErrorSink.Add(Errors.ClosureInstantiated, analyzer.SourceUnit, node.Span, type.FullName);
error_reported = true;
}
// type name resolved, look the constructor up:
constructor = analyzer.ResolveConstructor(type, node.Span, analyzer.CurrentType, analyzer.CurrentRoutine,
out runtimeVisibilityCheck);
if (constructor.ResolveOverload(analyzer, node.CallSignature, node.Span, out signature) == DRoutine.InvalidOverloadIndex)
{
if (!error_reported)
{
analyzer.ErrorSink.Add(Errors.ClassHasNoVisibleCtor, analyzer.SourceUnit, node.Span, type.FullName);
}
}
}
else
{
signature = UnknownSignature.Default;
}
CallSignatureHelpers.Analyze(node.CallSignature, analyzer, signature, info, false);
return(new Evaluation(node));
}
public override Evaluation Analyze(TypeOfEx node, Analyzer analyzer, ExInfoFromParent info)
{
access = info.Access;
typeArgsResolved = TypeRefHelper.Analyze(node.ClassNameRef, analyzer);
if (typeArgsResolved)
{
analyzer.AnalyzeConstructedType(TypeRefHelper.ResolvedType(node.ClassNameRef));
}
return(new Evaluation(node));
}
public override Evaluation Analyze(InstanceOfEx node, Analyzer analyzer, ExInfoFromParent info)
{
access = info.Access;
node.Expression = node.Expression.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
typeArgsResolved = TypeRefHelper.Analyze(node.ClassNameRef, analyzer);
if (typeArgsResolved)
{
analyzer.AnalyzeConstructedType(TypeRefHelper.ResolvedType(node.ClassNameRef));
}
return(new Evaluation(node));
}
public override PhpTypeCode Emit(NewEx node, CodeGenerator codeGenerator)
{
Statistics.AST.AddNode("NewEx");
PhpTypeCode result;
var newextype = TypeRefHelper.ResolvedType(node.ClassNameRef);
if (newextype != null && typeArgsResolved)
{
// constructor is resolvable (doesn't mean that known) //
result = newextype.EmitNew(codeGenerator, null, constructor, node.CallSignature, runtimeVisibilityCheck);
}
else
{
// constructor is unresolvable (a variable is used in type name => type is unresolvable as well) //
codeGenerator.EmitNewOperator(null, node.ClassNameRef, null, node.CallSignature);
result = PhpTypeCode.Object;
}
codeGenerator.EmitReturnValueHandling(node, false, ref result);
return(result);
}
public override bool IsCustomAttributeArgumentValue(TypeOfEx node)
{
var resolvedtype = TypeRefHelper.ResolvedType(node.ClassNameRef);
return(resolvedtype != null && typeArgsResolved && resolvedtype.IsDefinite);
}