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(T node, Analyzer analyzer, ExInfoFromParent info)
{
access = info.Access;
TypeRefHelper.Analyze(node.TypeRef, analyzer);
this.type = TypeRefHelper.ResolvedTypeOrUnknown(node.TypeRef);
analyzer.AnalyzeConstructedType(type);
return(new Evaluation(node));
}
/// <summary>
/// Resolves generic arguments.
/// </summary>
/// <returns><B>true</B> iff all arguments are resolvable to types or constructed types (none is variable).</returns>
internal virtual bool Analyze(T /*!*/ node, Analyzer /*!*/ analyzer)
{
bool result = true;
foreach (TypeRef arg in node.GenericParams)
{
result &= TypeRefHelper.Analyze(arg, analyzer);
}
return(result);
}
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));
}
internal override void ResolveName(T node, Analyzer analyzer)
{
var typeRef = node.TypeRef;
TypeRefHelper.Analyze(typeRef, analyzer);
this.type = TypeRefHelper.ResolvedTypeOrUnknown(typeRef);
// analyze constructed type (we are in the full analysis):
analyzer.AnalyzeConstructedType(type);
constant = analyzer.ResolveClassConstantName(type, node.Name, node.Span, analyzer.CurrentType, analyzer.CurrentRoutine,
out runtimeVisibilityCheck);
}
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 void Analyze(CatchItem /*!*/ node, Analyzer /*!*/ analyzer)
{
ExInfoFromParent info = new ExInfoFromParent(node);
info.Access = AccessType.Write;
TypeRefHelper.Analyze(node.TypeRef, analyzer);
resolvedType = TypeRefHelper.ResolvedTypeOrUnknown(node.TypeRef);
//resolvedType = analyzer.ResolveTypeName(node.ClassName, analyzer.CurrentType, analyzer.CurrentRoutine, node.Span, false);
node.Variable.Analyze(analyzer, info);
analyzer.EnterConditionalCode();
node.Statements.Analyze(analyzer);
analyzer.LeaveConditionalCode();
}
/// <summary>
/// Emits code that loads type descriptors for all generic arguments and a call to
/// <see cref="Operators.MakeGenericTypeInstantiation"/>.
/// </summary>
internal void EmitMakeGenericInstantiation(TypeRef node, CodeGenerator /*!*/ codeGenerator, ResolveTypeFlags flags)
{
if (node.GenericParams == null || node.GenericParams.Count == 0)
{
return;
}
ILEmitter il = codeGenerator.IL;
il.EmitOverloadedArgs(Types.DTypeDesc[0], node.GenericParams.Count, Methods.Operators.MakeGenericTypeInstantiation.ExplicitOverloads, delegate(ILEmitter eil, int i)
{
TypeRefHelper.EmitLoadTypeDesc(node.GenericParams[i], codeGenerator, flags);
});
if (node.GenericParams.Count > 0)
{
il.Emit(OpCodes.Call, Methods.Operators.MakeGenericTypeInstantiation.Overload(node.GenericParams.Count));
}
}
public void Analyze(CallSignature /*!*/ node, Analyzer /*!*/ analyzer, RoutineSignature /*!*/ signature, ExInfoFromParent info, bool isBaseCtorCallConstrained)
{
// generic:
foreach (var p in node.GenericParams)
{
TypeRefHelper.Analyze(p, analyzer);
}
// regular:
analyzer.EnterActualParams(signature, node.Parameters.Length);
foreach (var p in node.Parameters)
{
p.NodeCompiler <ActualParamCompiler>().Analyze(p, analyzer, isBaseCtorCallConstrained);
}
analyzer.LeaveActualParams();
}
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);
}
