public override void VisitGenericTypeRef(GenericTypeRef x)
{
VisitElement(x.TargetType);
var t = _results.Pop();
if (t.HasValue && !t.Value.IsGeneric)
{
bool resolved = true;
var generics = new GenericQualifiedName[x.GenericParams.Count];
for (int i = 0; i < generics.Length; i++)
{
VisitElement(x.GenericParams[i]);
var g = _results.Pop();
if (g.HasValue)
{
generics[i] = g.Value;
}
else
{
resolved = false;
}
}
if (resolved)
{
_results.Push(new GenericQualifiedName(t.Value.QualifiedName, generics));
return;
}
}
//
_results.Push(null);
}
public IndirectStMtdCall(Text.Span span,
GenericQualifiedName className, Text.Span classNamePosition, Expression /*!*/ nameExpr,
CallSignature signature)
: base(span, className, classNamePosition, signature)
{
_methodNameExpr = nameExpr;
}
public IndirectStMtdCall(Text.Span span,
GenericQualifiedName className, Text.Span classNamePosition, CompoundVarUse /*!*/ mtdNameVar,
IList <ActualParam> parameters, IList <TypeRef> genericParams)
: base(span, className, classNamePosition, parameters, genericParams)
{
this.methodNameVar = mtdNameVar;
}
public DirectStMtdCall(
Text.Span span, GenericQualifiedName className, Text.Span classNamePosition,
Name methodName, Text.Span methodNamePosition,
CallSignature signature)
: base(span, className, classNamePosition, signature)
{
this.methodName = new NameRef(methodNamePosition, methodName);
}
public CatchItem(Position p, GenericQualifiedName className, DirectVarUse /*!*/ variable,
List <Statement> /*!*/ statements)
: base(p)
{
Debug.Assert(variable != null && statements != null);
this.className = className;
this.variable = variable;
this.statements = statements;
}
private void fatalError(FlowController flow, bool removeFlowChildren)
{
var catchedType = new GenericQualifiedName(new QualifiedName(new Name(string.Empty)));
var catchVariable = new VariableIdentifier(string.Empty);
var description = new CatchBlockDescription(flow.ProgramEnd, catchedType, catchVariable);
var info = new ThrowInfo(description, new MemoryEntry());
var throws = new ThrowInfo[] { info };
flow.SetThrowBranching(throws, removeFlowChildren);
}
private void CheckReservedNamesAbsence(GenericQualifiedName genericName, Position position)
{
if (genericName.QualifiedName.IsReservedClassName)
{
errors.Add(Errors.CannotUseReservedName, SourceUnit, position, genericName.QualifiedName.Name);
}
if (genericName.GenericParams != null)
{
CheckReservedNamesAbsence(genericName.GenericParams, position);
}
}
/// <summary>
/// Creates new instance of CatchBlockDescription
/// </summary>
/// <param name="targetPoint">Point where to jump</param>
/// <param name="catchedType">Type of Exception</param>
/// <param name="catchVariable">Name of catched variables</param>
public CatchBlockDescription(ProgramPointBase targetPoint, GenericQualifiedName catchedType, VariableIdentifier catchVariable)
{
TargetPoint = targetPoint;
CatchedType = catchedType;
if (CatchedType.QualifiedName.Name.Value == null)
{
CatchedType = new GenericQualifiedName(new QualifiedName(new Name("$noname")));
}
CatchVariable = catchVariable;
}
internal static TypeRef FromGenericQualifiedName(Span span, GenericQualifiedName qname)
{
var tref = new ClassTypeRef(span, qname.QualifiedName);
if (qname.IsGeneric)
{
return(new GenericTypeRef(span, tref, qname.GenericParams.Select(p => FromObject(Span.Invalid, p)).ToList()));
}
else
{
return(tref);
}
}
private TryStmt /*!*/ CreateTryStmt(Position pos, List <Statement> /*!*/ tryStmts, Position classNamePos,
GenericQualifiedName /*!*/ className, Position variablePos, string /*!*/ variable,
List <Statement> /*!*/ catchStmts, List <CatchItem> catches)
{
CatchItem catch_item = new CatchItem(classNamePos, className, new DirectVarUse(variablePos,
new VariableName(variable)), catchStmts);
if (catches != null)
{
catches.Insert(0, catch_item);
}
else
{
catches = new List <CatchItem>();
catches.Add(catch_item);
}
return(new TryStmt(pos, tryStmts, catches));
}
internal ClassConstant TryResolveClassConstantGlobally(GenericQualifiedName typeName, VariableName constantName)
{
if (typeName.GenericParams.Length != 0)
{
return(null);
}
QualifiedName?alias;
DType type = ResolveTypeName(typeName.QualifiedName, Scope.Global, out alias, null, Position.Invalid, false);
ClassConstant constant;
if (type != null && type.IsDefinite && type.GetConstant(constantName, null, out constant) == GetMemberResult.OK)
{
return(constant);
}
else
{
return(null);
}
}
internal static DirectTypeRef /*!*/ FromGenericQualifiedName(Text.Span span, GenericQualifiedName genericQualifiedName)
{
List <TypeRef> genericParams;
if (genericQualifiedName.IsGeneric)
{
genericParams = new List <TypeRef>(genericQualifiedName.GenericParams.Length);
foreach (var obj in genericQualifiedName.GenericParams)
{
TypeRef objtype;
if (obj is GenericQualifiedName)
{
objtype = FromGenericQualifiedName(Text.Span.Invalid, (GenericQualifiedName)obj);
}
else if (obj is PrimitiveTypeName)
{
objtype = new PrimitiveTypeRef(Text.Span.Invalid, (PrimitiveTypeName)obj);
}
else
{
objtype = new PrimitiveTypeRef(Text.Span.Invalid, new PrimitiveTypeName(QualifiedName.Object));
}
genericParams.Add(objtype);
}
}
else
{
//if (genericQualifiedName.QualifiedName.IsPrimitiveTypeName)
// return new PrimitiveTypeRef(position, new PrimitiveTypeName(genericQualifiedName.QualifiedName));
genericParams = TypeRef.EmptyList;
}
return(new DirectTypeRef(span, genericQualifiedName.QualifiedName, genericParams.ToList()));
}
internal static DirectTypeRef/*!*/FromGenericQualifiedName(Text.Span span, GenericQualifiedName genericQualifiedName)
{
List<TypeRef> genericParams;
if (genericQualifiedName.IsGeneric)
{
genericParams = new List<TypeRef>(genericQualifiedName.GenericParams.Length);
foreach (var obj in genericQualifiedName.GenericParams)
{
TypeRef objtype;
if (obj is GenericQualifiedName) objtype = FromGenericQualifiedName(Text.Span.Invalid, (GenericQualifiedName)obj);
else if (obj is PrimitiveTypeName) objtype = new PrimitiveTypeRef(Text.Span.Invalid, (PrimitiveTypeName)obj);
else objtype = new PrimitiveTypeRef(Text.Span.Invalid, new PrimitiveTypeName(QualifiedName.Object));
genericParams.Add(objtype);
}
}
else
{
//if (genericQualifiedName.QualifiedName.IsPrimitiveTypeName)
// return new PrimitiveTypeRef(position, new PrimitiveTypeName(genericQualifiedName.QualifiedName));
genericParams = TypeRef.EmptyList;
}
return new DirectTypeRef(span, genericQualifiedName.QualifiedName, genericParams.ToList());
}
public IndirectStFldUse(Position position, GenericQualifiedName typeName, Expression/*!*/ fieldNameExpr)
: base(position, typeName)
{
this.fieldNameExpr = fieldNameExpr;
}
internal static DirectTypeRef/*!*/FromGenericQualifiedName(Position position, GenericQualifiedName genericQualifiedName)
{
var genericParams =
genericQualifiedName.GenericParams.Select<object, TypeRef>(obj =>
{
if (obj is PrimitiveType)
return new PrimitiveTypeRef(Position.Invalid, (PrimitiveType)obj);
if (obj is GenericQualifiedName)
return FromGenericQualifiedName(Position.Invalid, (GenericQualifiedName)obj);
return new PrimitiveTypeRef(Position.Invalid, PrimitiveType.Object);
});
return new DirectTypeRef(position, genericQualifiedName.QualifiedName, genericParams.ToList());
}
public StaticFieldUse(Position position, GenericQualifiedName typeName)
: base(position)
{
this.typeName = typeName;
}
public DType/*!*/ ResolveTypeName(GenericQualifiedName genericName, PhpType referringType,
PhpRoutine referringRoutine, Position position, bool mustResolve)
{
DType type = ResolveTypeName(genericName.QualifiedName, referringType, referringRoutine, position, mustResolve);
DTypeDesc[] arguments = (genericName.GenericParams.Length > 0) ? new DTypeDesc[genericName.GenericParams.Length] : DTypeDesc.EmptyArray;
for (int i = 0; i < arguments.Length; i++)
{
arguments[i] = ResolveType(genericName.GenericParams[i], referringType, referringRoutine, position, mustResolve).TypeDesc;
}
return type.MakeConstructedType(this, arguments, position);
}
public DirectStFldUse(Position position, GenericQualifiedName qualifiedName, Position qualifiedNamePosition, VariableName propertyName, Position propertyNamePosition)
: this(position, DirectTypeRef.FromGenericQualifiedName(qualifiedNamePosition, qualifiedName), propertyName, propertyNamePosition)
{
}
/// <summary> /// Resolve value, determined by given static field specifier on given type /// </summary> /// <param name="type">Type which static field is resolved</param> /// <param name="field">Possible fields</param> /// <returns>Snapshot entry for static field</returns> public abstract ReadWriteSnapshotEntryBase ResolveStaticField(GenericQualifiedName type, MemoryEntry field);
public StaticFieldUse(Text.Span span, Text.Span nameSpan, GenericQualifiedName typeName, Text.Span typeNamePosition)
: this(span, nameSpan, DirectTypeRef.FromGenericQualifiedName(typeNamePosition, typeName))
{
}
public DirectStFldUse(Text.Span span, GenericQualifiedName qualifiedName, Text.Span qualifiedNameSpan, VariableName propertyName, Text.Span propertyNameSpan)
: this(span, DirectTypeRef.FromGenericQualifiedName(qualifiedNameSpan, qualifiedName), propertyName, propertyNameSpan)
{
}
public DirectStFldUse(Position position, GenericQualifiedName qualifiedName, Position qualifiedNamePosition, VariableName propertyName, Position propertyNamePosition)
: this(position, DirectTypeRef.FromGenericQualifiedName(qualifiedNamePosition, qualifiedName), propertyName, propertyNamePosition)
{
}
internal override void Analyze(Analyzer/*!*/ analyzer)
{
// method redeclared:
if (method == null) return;
base.Analyze(analyzer);
PhpType declaring_type = analyzer.CurrentType;
analyzer.EnterMethodDeclaration(method);
typeSignature.Analyze(analyzer);
signature.Analyze(analyzer);
method.Validate(analyzer.ErrorSink);
// note, if the declaring type's base is unknown then it cannot be a CLR type;
ClrType base_clr_type = method.DeclaringType.Base as ClrType;
if (baseCtorParams != null)
{
if (base_clr_type != null)
{
AnalyzeBaseCtorCallParams(analyzer, base_clr_type);
}
else if (!method.IsConstructor || method.DeclaringType.Base == null || body == null)
{
analyzer.ErrorSink.Add(Errors.UnexpectedParentCtorInvocation, analyzer.SourceUnit, position);
baseCtorParams = null;
}
else if (method.DeclaringType.Base.Constructor == null)
{
// base class has no constructor, the default parameterless is silently called (and that does nothing);
// report error, if there are any parameters passed to the parameterless ctor:
if (baseCtorParams.Count > 0)
analyzer.ErrorSink.Add(Errors.UnexpectedParentCtorInvocation, analyzer.SourceUnit, position);
baseCtorParams = null;
}
else
{
GenericQualifiedName parent_name = new GenericQualifiedName(new QualifiedName(Name.ParentClassName));
DirectStMtdCall call_expr = new DirectStMtdCall(
position, parent_name, Position.Invalid,
method.DeclaringType.Base.Constructor.Name, Position.Invalid,
baseCtorParams, TypeRef.EmptyList);
body.Insert(0, new ExpressionStmt(position, call_expr));
baseCtorParams = null;
}
}
else
{
// the type immediately extends CLR type with no default ctor, yet there is no call to the base ctor;
// note, all constructor overloads reflected from the CLR type are visible as we are in a subclass:
if (method.IsConstructor && base_clr_type != null && !base_clr_type.ClrConstructor.HasParameterlessOverload)
{
analyzer.ErrorSink.Add(Errors.ExpectingParentCtorInvocation, analyzer.SourceUnit, position);
}
}
if(method.IsDllImport && !method.IsStatic)
analyzer.ErrorSink.Add(Errors.DllImportMethodMustBeStatic, analyzer.SourceUnit, position);
if(method.IsDllImport && method.IsAbstract)
analyzer.ErrorSink.Add(Errors.DllImportMethodCannotBeAbstract, analyzer.SourceUnit, position);
if (body != null)
body.Analyze(analyzer);
method.ValidateBody(analyzer.ErrorSink);
analyzer.LeaveMethodDeclaration();
// add entry point if applicable:
analyzer.SetEntryPoint(method, position);
}
public StaticFieldUse(Position position, Position namePosition, GenericQualifiedName typeName, Position typeNamePosition)
: this(position, namePosition, DirectTypeRef.FromGenericQualifiedName(typeNamePosition, typeName))
{
}
internal DirectStFldUse(Text.Span span, GenericQualifiedName qualifiedName, Span qualifiedNameSpan, VariableName propertyName, Span propertyNameSpan)
: this(span, TypeRef.FromGenericQualifiedName(qualifiedNameSpan, qualifiedName), propertyName, propertyNameSpan)
{
}
internal StaticFieldUse(Span span, GenericQualifiedName typeName, Span typeNamePosition)
: this(span, TypeRef.FromGenericQualifiedName(typeNamePosition, typeName))
{
}
public DirectStMtdCall(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition,
Name methodName, Text.Span methodNamePosition, List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams)
: base(span, methodNamePosition, className, classNamePosition, parameters, genericParams)
{
this.methodName = methodName;
}
public TypeDecl(SourceUnit/*!*/ sourceUnit,
Position position, Position entireDeclarationPosition, ShortPosition headingEndPosition, ShortPosition declarationBodyPosition,
bool isConditional, Scope scope, PhpMemberAttributes memberAttributes, bool isPartial, Name className,
NamespaceDecl ns, List<FormalTypeParam>/*!*/ genericParams, GenericQualifiedName? baseClassName,
List<GenericQualifiedName>/*!*/ implementsList, List<TypeMemberDecl>/*!*/ members,
List<CustomAttribute> attributes)
: base(position)
{
Debug.Assert(genericParams != null && implementsList != null && members != null);
this.name = className;
this.ns = ns;
this.typeSignature = new TypeSignature(genericParams);
this.baseClassName = baseClassName;
this.implementsList = implementsList;
this.members = members;
this.attributes = new CustomAttributes(attributes);
this.entireDeclarationPosition = entireDeclarationPosition;
this.headingEndPosition = headingEndPosition;
this.declarationBodyPosition = declarationBodyPosition;
this.partialKeyword = isPartial;
// remember current aliases:
var aliases = (ns != null) ? ns.Aliases : sourceUnit.Aliases;
if (aliases.Count > 0)
validAliases = new Dictionary<string, QualifiedName>(aliases);
// create stuff necessary for inclusion resolving process, other structures are created duirng analysis:
QualifiedName qn = (ns != null) ? new QualifiedName(name, ns.QualifiedName) : new QualifiedName(name);
type = new PhpType(qn, memberAttributes, isPartial, typeSignature, isConditional, scope, sourceUnit, position);
//// add alias for private classes (if not added yet by partial declaration):
//if (type.IsPrivate)
// sourceUnit.AddTypeAlias(qn, this.name);
// member-analysis needs the node:
type.Declaration.Node = this;
}
public ClassConstUse(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, string /*!*/ name, Text.Span namePosition)
: this(span, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), name, namePosition)
{
}
public CatchItem(Text.Span p, GenericQualifiedName className, DirectVarUse/*!*/ variable,
List<Statement>/*!*/ statements)
: base(p)
{
Debug.Assert(variable != null && statements != null);
this.className = className;
this.variable = variable;
this.statements = statements;
}
public StaticFieldUse(Text.Span span, Text.Span nameSpan, GenericQualifiedName typeName, Text.Span typeNamePosition)
: this(span, nameSpan, DirectTypeRef.FromGenericQualifiedName(typeNamePosition, typeName))
{
}
/// <summary>
/// Static method call.
/// </summary>
/// <param name="span">Entire element span.</param>
/// <param name="className">Name of the containing class.</param>
/// <param name="classNamePosition">Class name position.</param>
/// <param name="parameters">Actual parameters.</param>
/// <param name="genericParams">Generic parameters.</param>
internal StaticMtdCall(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, IList <ActualParam> parameters, IList <TypeRef> genericParams)
: this(span, TypeRef.FromGenericQualifiedName(classNamePosition, className), parameters, genericParams)
{
}
public ClassConstUse(Position position, GenericQualifiedName className, Position classNamePosition, string /*!*/ name, Position namePosition)
: this(position, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), name, namePosition)
{
}
public DirectStMtdCall(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition,
Name methodName, Text.Span methodNamePosition, IList <ActualParam> parameters, IList <TypeRef> genericParams)
: base(span, className, classNamePosition, parameters, genericParams)
{
this.methodName = new NameRef(methodNamePosition, methodName);
}
/// <summary>
/// Create new Instance Of CatchBasicBlock
/// </summary>
/// <param name="variable">Variable name of catch Exception</param>
/// <param name="className">Class of catch Exception</param>
public CatchBasicBlock(DirectVarUse /*!*/ variable, GenericQualifiedName className)
: base()
{
Variable = variable;
ClassName = className;
}
public DirectStMtdCall(Position position, GenericQualifiedName className, Name methodName, List<ActualParam>/*!*/ parameters,
List<TypeRef>/*!*/ genericParams)
: base(position, className, parameters, genericParams)
{
this.methodName = methodName;
}
private VariableUse CreateStaticFieldUse(Position position, GenericQualifiedName /*!*/ className, Position classNamePosition, CompoundVarUse /*!*/ field)
{
return(CreateStaticFieldUse(position, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), field));
}
public StaticMtdCall(Position position, GenericQualifiedName className, List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams)
: this(position, DirectTypeRef.FromGenericQualifiedName(position, className), parameters, genericParams)
{
}
public DirectStFldUse(Position position, GenericQualifiedName typeName, VariableName propertyName)
: base(position, typeName)
{
this.propertyName = propertyName;
}
public override ReadWriteSnapshotEntryBase ResolveStaticField(GenericQualifiedName type, MemoryEntry field)
{
throw new NotImplementedException();
}
public IndirectStMtdCall(Text.Span span,
GenericQualifiedName className, Text.Span classNamePosition, CompoundVarUse/*!*/ mtdNameVar,
IList<ActualParam> parameters, IList<TypeRef> genericParams)
: base(span, mtdNameVar.Span, className, classNamePosition, parameters, genericParams)
{
this.methodNameVar = mtdNameVar;
}
public DirectStFldUse(Position position, GenericQualifiedName qualifiedName, VariableName propertyName)
: base(position, DirectTypeRef.FromGenericQualifiedName(position, qualifiedName))
{
}
public StaticMtdCall(Text.Span span, Text.Span methodNamePosition, GenericQualifiedName className, Text.Span classNamePosition, List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams)
: this(span, methodNamePosition, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), parameters, genericParams)
{
}
public PseudoClassConstUse(Position position, GenericQualifiedName className, Position classNamePosition, Types type, Position namePosition)
: this(position, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), type, namePosition)
{
}
public StaticMtdCall(Position position, GenericQualifiedName className, List<ActualParam>/*!*/ parameters,
List<TypeRef>/*!*/ genericParams)
: base(position, parameters, genericParams)
{
this.className = className;
}
public TypeHintValue(GenericQualifiedName hint)
: this((object)hint)
{
}
public ClassConstUse(Position position, GenericQualifiedName className, Position classNamePosition, string/*!*/ name, Position namePosition)
: this(position, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), name, namePosition)
{
}
/// <summary> /// Resolve value, determined by given static field specifier on given type /// </summary> /// <param name="type">Type which static field is resolved</param> /// <param name="field">Specifier of resolved field</param> /// <returns>Snapshot entry for static field</returns> public abstract ReadWriteSnapshotEntryBase ResolveStaticField(GenericQualifiedName type, VariableIdentifier field);
public StaticFieldUse(Position position, Position namePosition, GenericQualifiedName typeName, Position typeNamePosition)
: this(position, namePosition, DirectTypeRef.FromGenericQualifiedName(typeNamePosition, typeName))
{
}
internal static DirectTypeRef /*!*/ FromGenericQualifiedName(Position position, GenericQualifiedName genericQualifiedName)
{
var genericParams =
genericQualifiedName.GenericParams.Select <object, TypeRef>(obj =>
{
if (obj is PrimitiveType)
{
return(new PrimitiveTypeRef(Position.Invalid, (PrimitiveType)obj));
}
if (obj is GenericQualifiedName)
{
return(FromGenericQualifiedName(Position.Invalid, (GenericQualifiedName)obj));
}
return(new PrimitiveTypeRef(Position.Invalid, PrimitiveType.Object));
});
return(new DirectTypeRef(position, genericQualifiedName.QualifiedName, genericParams.ToList()));
}
public IndirectStMtdCall(Position position, GenericQualifiedName className, CompoundVarUse/*!*/ mtdNameVar,
List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams)
: base(position, className, parameters, genericParams)
{
this.methodNameVar = mtdNameVar;
}
public PseudoClassConstUse(Position position, GenericQualifiedName className, Position classNamePosition, Types type, Position namePosition)
: this(position, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), type, namePosition)
{
}
public ClassConstUse(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, string/*!*/ name, Text.Span namePosition)
: this(span, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), name, namePosition)
{
}
public PseudoClassConstUse(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, Types type, Text.Span namePosition)
: this(span, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), type, namePosition)
{
}
internal PseudoClassConstUse(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, Types type, Text.Span namePosition)
: this(span, ClassTypeRef.FromGenericQualifiedName(classNamePosition, className), type, namePosition)
{
}
public ClassConstUse(Position position, GenericQualifiedName className, string/*!*/ name)
: base(position)
{
this.className = className;
this.name = new VariableName(name);
}
