- Fix function header not being stored correctly for a FunctionExpression

- Fixed type parameters stored as null instead of empty array

CodeModel/src/main/java/org/openzen/zenscript/codemodel/FunctionHeader.java

 		for (int i = 0; i < parameters.length; i++) {
 			parameters[i] = this.parameters[i].withGenericArguments(mapper);
 		}
-		return new FunctionHeader(null, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
+		return new FunctionHeader(TypeParameter.NONE, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
 	}
 	
 	public FunctionHeader forTypeParameterInference() {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/Expression.java

 				if (body == function.body)
 					return function;
 				
-				return new FunctionExpression(function.position, (FunctionTypeID)function.type, function.closure, body);
+				return new FunctionExpression(function.position, (FunctionTypeID)function.type, function.closure, function.header, body);
 			} else {
 				return expression;
 			}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/FunctionExpression.java

 			CodePosition position,
 			FunctionTypeID type,
 			LambdaClosure closure,
+			FunctionHeader header,
 			Statement body) {
 		super(position, type, body.thrownType);
 		
-		this.header = type.header;
+		this.header = header;
 		this.closure = closure;
 		this.body = body;
 	}
 	@Override
 	public FunctionExpression transform(ExpressionTransformer transformer) {
 		Statement tBody = body.transform(transformer, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
-		return tBody == body ? this : new FunctionExpression(position, (FunctionTypeID)type, closure, tBody);
+		return tBody == body ? this : new FunctionExpression(position, (FunctionTypeID)type, closure, header, tBody);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/DefinitionScope.java

 		this.outer = outer;
 		this.definition = definition;
 		
-		ITypeID[] genericParameterList = null;
+		ITypeID[] genericParameterList = ITypeID.NONE;
 		if (definition.genericParameters != null) {
 			genericParameterList = new ITypeID[definition.genericParameters.length];
 			for (int i = 0; i < definition.genericParameters.length; i++) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java

 		if (definition.genericParameters != null)
 			throw new IllegalArgumentException("Definition has type arguments!");
 		
-		return new DefinitionTypeID(definition, null);
+		return new DefinitionTypeID(definition, ITypeID.NONE);
 	}
 	
 	private static final OuterTypeEntry[] NO_OUTER_ENTRIES = new OuterTypeEntry[0];
 	
 	// For inner classes of generic outer classes
 	public DefinitionTypeID(HighLevelDefinition definition, ITypeID[] typeParameters, Map<TypeParameter, ITypeID> outerTypeParameters) {
+		if (typeParameters == null)
+			throw new NullPointerException("typeParameters cannot be null");
+		
 		this.definition = definition;
 		this.typeParameters = typeParameters;
 		this.outerTypeParameters = outerTypeParameters;
 	}
 	
 	public boolean hasTypeParameters() {
-		return typeParameters != null && typeParameters.length > 0;
+		return typeParameters.length > 0;
 	}
 	
 	public void init(GlobalTypeRegistry registry) {
 	// To be used exclusively by StaticDefinitionTypeID
 	protected DefinitionTypeID(HighLevelDefinition definition) {
 		this.definition = definition;
-		this.typeParameters = null;
+		this.typeParameters = ITypeID.NONE;
 		this.superType = definition.superType;
 		this.outerTypeParameters = Collections.emptyMap();
 		this.outerTypeEntries = NO_OUTER_ENTRIES;
 		if (!hasTypeParameters() && outerTypeParameters.isEmpty())
 			return this;
 		
-		ITypeID[] instancedArguments = null;
-		if (typeParameters != null) {
+		ITypeID[] instancedArguments = ITypeID.NONE;
+		if (hasTypeParameters()) {
 			instancedArguments = new ITypeID[typeParameters.length];
 			for (int i = 0; i < typeParameters.length; i++) {
 				// TODO: why was this line written like this?
 	
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
-		if (typeParameters != null) {
+		if (hasTypeParameters()) {
 			for (ITypeID typeParameter : typeParameters)
 				if (typeParameter.hasInferenceBlockingTypeParameters(parameters))
 					return true;
 	
 	@Override
 	public String toString() {
-		if (typeParameters == null) {
+		if (!hasTypeParameters()) {
 			return definition.name;
 		} else {
 			StringBuilder result = new StringBuilder();

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GenericName.java

 	public final ITypeID[] arguments;
 	
 	public GenericName(String name) {
-		this(name, null);
+		this(name, ITypeID.NONE);
 	}
 	
 	public GenericName(String name, ITypeID[] arguments) {
+		if (arguments == null)
+			throw new NullPointerException("Arguments cannot be null");
+		
 		this.name = name;
 		this.arguments = arguments;
 	}
 	
 	public int getNumberOfArguments() {
-		return arguments == null ? 0 : arguments.length;
+		return arguments.length;
 	}
 	
 	public boolean hasArguments() {
-		return arguments != null && arguments.length > 0;
+		return arguments.length > 0;
 	}
 	
 	public boolean hasNoArguments() {
-		return arguments == null || arguments.length == 0;
+		return arguments.length == 0;
 	}
 	
 	@Override
 	public String toString() {
 		StringBuilder result = new StringBuilder(name);
-		if (arguments != null) {
+		if (hasArguments()) {
 			result.append("<");
 			for (int i = 0; i < arguments.length; i++) {
 				if (i > 0)

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GlobalTypeRegistry.java

 	
 	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, ITypeID[] typeParameters, Map<TypeParameter, ITypeID> outerInstance) {
 		DefinitionTypeID id;
-		if ((definition instanceof FunctionDefinition) || (definition.genericParameters == null && typeParameters == null && outerInstance.isEmpty())) {
+		if ((definition instanceof FunctionDefinition) || (definition.genericParameters == null && typeParameters.length == 0 && outerInstance.isEmpty())) {
 			// make it a static one
 			id = new StaticDefinitionTypeID(definition);
 		} else {

DrawableGui/src/main/java/org/openzen/drawablegui/DTooltip.java → DrawableGui/src/main/java/org/openzen/drawablegui/DSimpleTooltip.java

 package org.openzen.drawablegui;
 
 import org.openzen.drawablegui.listeners.ListenerHandle;
-import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.LiveString;
-import org.openzen.drawablegui.live.MutableLiveObject;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylePath;
 
  *
  * @author Hoofdgebruiker
  */
-public class DTooltip implements DComponent {
+public class DSimpleTooltip {
 	private final DStyleClass styleClass;
 	private final LiveString tooltip;
-	private final MutableLiveObject<DSizing> sizing = DSizing.create();
 	private final ListenerHandle<LiveString.Listener> tooltipListener;
 	
 	private DUIContext context;
 	private boolean visible = false;
 	private DTimerHandle timerHandle = null;
 	
-	public DTooltip(DStyleClass styleClass, LiveString tooltip) {
+	public DSimpleTooltip(DStyleClass styleClass, LiveString tooltip) {
 		this.styleClass = styleClass;
 		this.tooltip = tooltip;
 		tooltipListener = tooltip.addListener(this::onTooltipChanged);
 	}
 	
 	private void onTooltipChanged(String oldValue, String newValue) {
-		if (context == null)
+		if (context == null || bounds == null)
 			return;
 		
-		sizing.setValue(new DSizing(
-				style.border.getPaddingLeft() + fontMetrics.getWidth(newValue) + style.border.getPaddingRight(),
-				style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingBottom()));
+		bounds = new DIRectangle(
+				bounds.x,
+				bounds.y,
+				style.border.getPaddingLeft() + fontMetrics.getWidth(tooltip.getValue()) + style.border.getPaddingRight(),
+				style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingBottom());
+		context.repaint(bounds);
 	}
 	
 	public void onTargetMouseEnter(DMouseEvent e) {
 			timerHandle.close();
 		
 		timerHandle = context.setTimer(1000, this::show);
-		setBounds(new DIRectangle(e.x, e.y, sizing.getValue().preferredWidth, sizing.getValue().preferredHeight));
+		bounds = new DIRectangle(
+				e.x,
+				e.y,
+				style.border.getPaddingLeft() + fontMetrics.getWidth(tooltip.getValue()) + style.border.getPaddingRight(),
+				style.border.getPaddingTop() + fontMetrics.getAscent() + fontMetrics.getDescent() + style.border.getPaddingBottom());
 	}
 	
 	public void onTargetMouseExit(DMouseEvent e) {
 	}
 	
 	private void show() {
+		System.out.println("Show tooltip");
 		visible = true;
 		context.repaint(bounds);
 		
 	}
 	
 	private void hide() {
+		System.out.println("Hide tooltip");
 		visible = false;
 		context.repaint(bounds);
 	}
 	
-	@Override
 	public void setContext(DStylePath parent, DUIContext context) {
 		this.context = context;
 		
 		style = new DTooltipStyle(context.getStylesheets().get(context, path));
 		fontMetrics = context.getFontMetrics(style.font);
 	}
-
-	@Override
-	public LiveObject<DSizing> getSizing() {
-		return sizing;
-	}
-
-	@Override
-	public DIRectangle getBounds() {
-		return bounds;
-	}
-
-	@Override
-	public int getBaselineY() {
-		return style.border.getPaddingTop() + fontMetrics.getAscent();
-	}
-
-	@Override
-	public void setBounds(DIRectangle bounds) {
-		this.bounds = bounds;
-	}
-
-	@Override
+	
 	public void paint(DCanvas canvas) {
 		if (!visible)
 			return;
 		
+		System.out.println("Actually paint tooltip");
 		canvas.fillRectangle(bounds.x, bounds.y, bounds.width, bounds.height, style.backgroundColor);
 		style.border.paint(canvas, bounds);
-		canvas.drawText(style.font, style.textColor, bounds.x + style.border.getPaddingLeft(), style.border.getPaddingTop(), tooltip.getValue());
+		canvas.drawText(style.font, style.textColor, bounds.x + style.border.getPaddingLeft(), bounds.y + style.border.getPaddingTop(), tooltip.getValue());
 	}
-
-	@Override
+	
 	public void close() {
 		tooltipListener.close();
 	}

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/aspectbar/AspectBarSelectorButton.java

 import org.openzen.drawablegui.DTransform2D;
 import org.openzen.drawablegui.DUIContext;
 import org.openzen.drawablegui.DIRectangle;
+import org.openzen.drawablegui.DSimpleTooltip;
 import org.openzen.drawablegui.listeners.ListenerHandle;
+import org.openzen.drawablegui.live.ImmutableLiveString;
 import org.openzen.drawablegui.live.LiveBool;
 import org.openzen.drawablegui.live.LiveObject;
 import org.openzen.drawablegui.live.MutableLiveObject;
 	private DPath shape;
 	private boolean hovering;
 	private boolean pressing;
+	private DSimpleTooltip tooltip;
 	
 	private final ListenerHandle<LiveBool.Listener> activeListener;
 	
-	public AspectBarSelectorButton(DStyleClass styleClass, DDrawable icon, LiveBool active, Consumer<DMouseEvent> onClick) {
+	public AspectBarSelectorButton(DStyleClass styleClass, DDrawable icon, LiveBool active, String tooltip, Consumer<DMouseEvent> onClick) {
 		this.active = active;
 		this.styleClass = styleClass;
 		this.icon = icon;
 		this.onClick = onClick;
+		this.tooltip = new DSimpleTooltip(DStyleClass.EMPTY, new ImmutableLiveString(tooltip));
 		
 		activeListener = active.addListener((oldValue, newValue) -> repaint());
 	}
 				style.width,
 				style.height,
 				style.roundingRadius);
+		
+		tooltip.setContext(parent, context);
 	}
 
 	@Override
 				bounds.x + (style.width - icon.getNominalWidth() * context.getScale()) / 2,
 				bounds.y + (style.height - icon.getNominalHeight() * context.getScale()) / 2,
 				context.getScale()));
+		tooltip.paint(canvas);
 	}
 	
 	@Override
 	public void onMouseEnter(DMouseEvent e) {
 		hovering = true;
+		tooltip.onTargetMouseEnter(e);
 		repaint();
 	}
 	
 	public void onMouseExit(DMouseEvent e) {
 		hovering = false;
 		pressing = false;
+		tooltip.onTargetMouseExit(e);
 		repaint();
 	}
 	
 	@Override
 	public void close() {
 		activeListener.close();
+		tooltip.close();
 	}
 	
 	private void repaint() {

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/aspectbar/AspectBarView.java

 				aspectBar.toolbars,
 				bar -> {
 					LiveBool buttonActive = new LivePredicateBool<>(aspectBar.active, activeBar -> activeBar == bar);
-					AspectBarSelectorButton button = new AspectBarSelectorButton(DStyleClass.EMPTY, bar.icon, buttonActive, e -> aspectBar.active.setValue(bar));
+					AspectBarSelectorButton button = new AspectBarSelectorButton(DStyleClass.EMPTY, bar.icon, buttonActive, bar.description, e -> aspectBar.active.setValue(bar));
 					if (context != null)
 						button.setContext(path, context);
 					

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedCallArguments.java

 			innerScope = scope.forCall(candidates.get(0));
 		} else {
 			candidates = candidates.stream()
-					.filter(candidate -> candidate.typeParameters == null)
+					.filter(candidate -> candidate.getNumberOfTypeParameters() == 0)
 					.collect(Collectors.toList());
 			
 			if (candidates.isEmpty()) {

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionFunction.java

 		}
 		
 		FunctionTypeID functionType = scope.getTypeRegistry().getFunction(genericHeader.withGenericArguments(new GenericMapper(scope.getTypeRegistry(), scope.genericInferenceMap)));
-		return new FunctionExpression(position, functionType, closure, statements);
+		definedHeader = definedHeader.forLambda(functionType.header);
+		return new FunctionExpression(position, functionType, closure, definedHeader, statements);
 	}
 	
 	@Override

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionVariable.java

 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
-		ITypeID[] genericArguments = null;
+		ITypeID[] genericArguments = ITypeID.NONE;
 		if (genericParameters != null) {
 			genericArguments = new ITypeID[genericParameters.size()];
 			for (int i = 0; i < genericParameters.size(); i++) {

Parser/src/main/java/org/openzen/zenscript/parser/type/IParsedType.java

 	}
 	
 	public static ITypeID[] compileList(List<IParsedType> typeParameters, BaseScope scope) {
-		ITypeID[] result = null;
+		ITypeID[] result = ITypeID.NONE;
 		if (typeParameters != null) {
 			result = new ITypeID[typeParameters.size()];
 			for (int i = 0; i < typeParameters.size(); i++) {