| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.netbeans.modules.javascript2.model; |
| |
| import org.netbeans.modules.javascript2.model.api.ModelUtils; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.EnumSet; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| import org.netbeans.modules.csl.api.Modifier; |
| import org.netbeans.modules.csl.api.OffsetRange; |
| import org.netbeans.modules.javascript2.doc.spi.JsDocumentationHolder; |
| import org.netbeans.modules.javascript2.model.api.JsElement; |
| import org.netbeans.modules.javascript2.model.api.JsFunction; |
| import org.netbeans.modules.javascript2.model.api.JsObject; |
| import org.netbeans.modules.javascript2.types.api.DeclarationScope; |
| import org.netbeans.modules.javascript2.types.api.Identifier; |
| import org.netbeans.modules.javascript2.types.api.Type; |
| import org.netbeans.modules.javascript2.types.api.TypeUsage; |
| import org.openide.filesystems.FileObject; |
| |
| /** |
| * |
| * @author Petr Pisl |
| */ |
| public class JsFunctionImpl extends DeclarationScopeImpl implements JsFunction { |
| |
| final private HashMap <String, JsObject> parametersByName; |
| final private List<JsObject> parameters; |
| final private Set<TypeUsage> returnTypes; |
| private boolean isStrict; |
| |
| public JsFunctionImpl(DeclarationScope scope, JsObject parentObject, Identifier name, |
| List<Identifier> parameters, OffsetRange offsetRange, String mimeType, String sourceLabel) { |
| super(scope, parentObject, name, offsetRange, mimeType, sourceLabel); |
| this.parametersByName = new HashMap<String, JsObject>(parameters.size()); |
| this.parameters = new ArrayList<JsObject>(parameters.size()); |
| for (Identifier identifier : parameters) { |
| JsObject parameter = new ParameterObject(this, identifier, mimeType, sourceLabel); |
| addParameter(parameter); |
| } |
| setAnonymous(false); |
| this.returnTypes = new HashSet<TypeUsage>(); |
| setDeclared(true); |
| if (parentObject != null) { |
| // creating arguments variable |
| JsObjectImpl arguments = new JsObjectImpl(this, |
| new Identifier(ModelUtils.ARGUMENTS, new OffsetRange(name.getOffsetRange().getStart(), name.getOffsetRange().getStart())), |
| name.getOffsetRange(), false, EnumSet.of(Modifier.PRIVATE), mimeType, sourceLabel); |
| arguments.addAssignment(new TypeUsage("Arguments", getOffset(), true), getOffset()); // NOI18N |
| this.addProperty(arguments.getName(), arguments); |
| } |
| } |
| |
| protected JsFunctionImpl(FileObject file, JsObject parentObject, Identifier name, |
| List<Identifier> parameters, String mimeType, String sourceLabel) { |
| this(null, parentObject, name, parameters, name.getOffsetRange(), mimeType, sourceLabel); |
| this.setFileObject(file); |
| this.setDeclared(false); |
| } |
| |
| private JsFunctionImpl(FileObject file, Identifier name, String mimeType, String sourceLabel) { |
| this(null, null, name, Collections.emptyList(), name.getOffsetRange(), mimeType, sourceLabel); |
| this.setFileObject(file); |
| } |
| |
| public static JsFunctionImpl createGlobal(FileObject fileObject, int length, String mimeType) { |
| String name = fileObject != null ? fileObject.getName() : "VirtualSource"; //NOI18N |
| Identifier ident = new Identifier(name, new OffsetRange(0, length)); |
| return new JsFunctionImpl(fileObject, ident, mimeType, null); |
| } |
| |
| @Override |
| public final Collection<? extends JsObject> getParameters() { |
| return this.parameters; |
| } |
| |
| public final void addParameter(JsObject object) { |
| assert object.getParent() == this; |
| this.parametersByName.put(object.getName(), object); |
| this.parameters.add(object); |
| } |
| |
| @Override |
| public Kind getJSKind() { |
| if (kind != null) { |
| return kind; |
| } |
| if (getParent() == null) { |
| // global function |
| return JsElement.Kind.FILE; |
| } |
| String name = getName(); |
| if (name != null && name.startsWith("get ")) { //NOI18N |
| return JsElement.Kind.PROPERTY_GETTER; |
| } |
| if (name != null && name.startsWith("set ")) { //NOI18N |
| return JsElement.Kind.PROPERTY_SETTER; |
| } |
| if (getParent() != null /*&& getParent() instanceof JsFunction*/) { |
| JsObject prototype = null; |
| for (JsObject property : getProperties().values()) { |
| if (property.isDeclared() |
| && (property.getModifiers().contains(Modifier.PROTECTED) |
| || (property.getModifiers().contains(Modifier.PUBLIC) && !property.getModifiers().contains(Modifier.STATIC))) |
| && !isAnonymous() && !property.isAnonymous() |
| && (property.getDeclarationName() != null && property.getDeclarationName().getOffsetRange().getStart() < property.getDeclarationName().getOffsetRange().getEnd())) { |
| if(!ModelUtils.PROTOTYPE.equals(getParent().getName())) { |
| return JsElement.Kind.CONSTRUCTOR; |
| } |
| } |
| if (ModelUtils.PROTOTYPE.equals(property.getName())) { |
| prototype = property; |
| } |
| } |
| if (prototype != null /*&& !prototype.getProperties().isEmpty()*/) { |
| return JsElement.Kind.CONSTRUCTOR; |
| } |
| } |
| // if (getParent() != null && !getParent().isDeclared()) { |
| // |
| // } |
| |
| JsElement.Kind result = JsElement.Kind.FUNCTION; |
| |
| if (!(getParent() instanceof JsObjectReference) && getParent().getJSKind() != JsElement.Kind.FILE) { |
| result = JsElement.Kind.METHOD; |
| } |
| return result; |
| } |
| |
| @Override |
| public JsObject getParameter(String name) { |
| JsObject result = parametersByName.get(name); |
| return result; |
| } |
| |
| private boolean areReturnTypesResolved = false; |
| |
| @Override |
| public Collection<? extends TypeUsage> getReturnTypes() { |
| if (areReturnTypesResolved) { |
| return Collections.emptyList(); |
| } |
| Collection<TypeUsage> returns = new HashSet<>(); |
| HashSet<String> nameReturnTypes = new HashSet<>(); |
| areReturnTypesResolved = true; |
| for(TypeUsage type : returnTypes) { |
| if (type.isResolved()) { |
| if (!nameReturnTypes.contains(type.getType())){ |
| returns.add(type); |
| nameReturnTypes.add(type.getType()); |
| } |
| } else { |
| if (type.getType().startsWith("@")) { |
| String typeName = type.getType(); |
| if (!(typeName.endsWith(getName()) && typeName.startsWith("@call"))) { |
| Collection<TypeUsage> resolved = ModelUtils.resolveTypeFromSemiType(this, type); |
| for (TypeUsage typeResolved : resolved) { |
| if (!nameReturnTypes.contains(type.getType())) { |
| returns.add(typeResolved); |
| nameReturnTypes.add(typeResolved.getType()); |
| } |
| } |
| } |
| } else { |
| JsObject jsObject = ModelUtils.getJsObjectByName(this,type.getType()); |
| if (jsObject == null) { |
| // try to find according the fqn |
| JsObject global = ModelUtils.getGlobalObject(this); |
| jsObject = ModelUtils.findJsObjectByName(global, type.getType()); |
| } |
| if(jsObject != null) { |
| Collection<TypeUsage> resolveAssignments = resolveAssignments(jsObject, type.getOffset()); |
| for (TypeUsage typeResolved: resolveAssignments) { |
| if (!nameReturnTypes.contains(typeResolved.getType())){ |
| returns.add(typeResolved); |
| nameReturnTypes.add(typeResolved.getType()); |
| } |
| } |
| } else { |
| returns.add(type); |
| nameReturnTypes.add(type.getType()); |
| } |
| } |
| } |
| } |
| areReturnTypesResolved = false; |
| return returns; |
| } |
| |
| @Override |
| public void addReturnType(TypeUsage type) { |
| boolean isThere = false; |
| for (TypeUsage typeUsage : this.returnTypes) { |
| if (type.getType().equals(typeUsage.getType())) { |
| isThere = true; |
| } |
| } |
| if (!isThere){ |
| this.returnTypes.add(type); |
| } |
| } |
| |
| public void addReturnType(Collection<TypeUsage> types) { |
| for (TypeUsage typeUsage : types) { |
| addReturnType(typeUsage); |
| } |
| } |
| |
| public boolean areReturnTypesEmpty() { |
| return returnTypes.isEmpty(); |
| } |
| |
| @Override |
| public boolean moveProperty(String name, JsObject newParent) { |
| JsObject property = getProperty(name); |
| if (property != null && (newParent instanceof DeclarationScope)) { |
| ModelUtils.changeDeclarationScope(property, (DeclarationScope)newParent); |
| } |
| return super.moveProperty(name, newParent); |
| } |
| |
| @Override |
| public void resolveTypes(JsDocumentationHolder docHolder) { |
| super.resolveTypes(docHolder); |
| if (!(returnTypes.size() == 1 && Type.UNDEFINED.equals(returnTypes.iterator().next().getType()))) { |
| HashSet<String> nameReturnTypes = new HashSet<String>(); |
| Collection<TypeUsage> resolved = new ArrayList<>(); |
| for (TypeUsage type : returnTypes) { |
| if (!(type.getType().equals(Type.UNRESOLVED) && returnTypes.size() > 1)) { |
| if (!type.isResolved()) { |
| for (TypeUsage rType : ModelUtils.resolveTypeFromSemiType(this, type)) { |
| if (!nameReturnTypes.contains(rType.getType())) { |
| if ("@this;".equals(type.getType())) { // NOI18N |
| rType = new TypeUsage(rType.getType(), -1, rType.isResolved()); |
| } |
| resolved.add(rType); |
| nameReturnTypes.add(rType.getType()); |
| } |
| } |
| // resolved.addAll(ModelUtils.resolveTypeFromSemiType(this, type)); |
| } else { |
| if (!nameReturnTypes.contains(type.getType())) { |
| resolved.add(type); |
| nameReturnTypes.add(type.getType()); |
| } |
| } |
| } |
| } |
| |
| for (TypeUsage type : resolved) { |
| if (type.getOffset() > 0) { |
| String typeName = type.getType(); |
| JsObject jsObject = null; |
| // at first check whether is not a parameter |
| if (typeName.indexOf('.') == -1) { |
| JsObject parameter = null; |
| DeclarationScope scope = this; |
| while (scope != null && parameter == null && jsObject == null) { |
| if (scope instanceof JsFunction) { |
| parameter = ((JsFunction) scope).getParameter(typeName); |
| } |
| jsObject = ((JsObject) scope).getProperty(typeName); |
| scope = scope.getParentScope(); |
| } |
| if (jsObject == null && parameter != null) { |
| jsObject = parameter; |
| } |
| if (jsObject != null) { |
| jsObject.addOccurrence(new OffsetRange(type.getOffset(), type.getOffset() + typeName.length())); |
| } |
| } |
| if (jsObject == null) { |
| jsObject = ModelUtils.findJsObjectByName(this, typeName); |
| if (jsObject == null) { |
| JsObject global = ModelUtils.getGlobalObject(this); |
| jsObject = ModelUtils.findJsObjectByName(global, typeName); |
| } |
| if (jsObject != null && containsOffset(type.getOffset()) && !getJSKind().equals(JsElement.Kind.FILE)) { |
| int index = typeName.lastIndexOf('.'); |
| int typeLength = (index > -1) ? typeName.length() - index - 1 : typeName.length(); |
| ((JsObjectImpl)jsObject).addOccurrence(new OffsetRange(type.getOffset(), jsObject.isAnonymous() ? type.getOffset() : type.getOffset() + typeLength)); |
| } |
| } |
| } |
| } |
| returnTypes.clear(); |
| returnTypes.addAll(resolved); |
| } else if (getJSKind() == JsElement.Kind.CONSTRUCTOR) { |
| Collection<TypeUsage> resolved = ModelUtils.resolveTypeFromSemiType(this, returnTypes.iterator().next()); |
| returnTypes.clear(); |
| returnTypes.addAll(resolved); |
| } else if (returnTypes.size() == 1) { |
| TypeUsage type = returnTypes.iterator().next(); |
| if (Type.UNDEFINED.equals(type.getType()) && !type.isResolved()) { |
| returnTypes.clear(); |
| returnTypes.add(new TypeUsage(type.getType(), type.getOffset(), true)); |
| } |
| } |
| |
| // parameters and type type resolving for occurrences |
| JsObject global = ModelUtils.getGlobalObject(this); |
| for(JsObject param : parameters) { |
| Collection<? extends TypeUsage> types = param.getAssignmentForOffset(param.getDeclarationName().getOffsetRange().getStart()); |
| for(TypeUsage type: types) { |
| JsObject jsObject = ModelUtils.findJsObjectByName(global, type.getType());//getJsObjectByName(this, type.getType()); |
| if (jsObject != null) { |
| ModelUtils.addDocTypesOccurence(jsObject, docHolder); |
| moveOccurrenceOfProperties((JsObjectImpl)jsObject, param); |
| if (type.getType().indexOf('.') > -1) { |
| // mark occurrences also for the parent if the type is like Contex.Object |
| String[] typeParts = type.getType().split("\\."); |
| JsObject parent = jsObject.getParent(); |
| for (int i = (typeParts.length - 2); i > -1 && parent != null; i--) { |
| if (parent.getName().equals(typeParts[i])) { |
| ModelUtils.addDocTypesOccurence(parent, docHolder); |
| } |
| parent = parent.getParent(); |
| } |
| } |
| } |
| } |
| List<JsObject> paramProperties = new ArrayList<>(param.getProperties().values()); |
| for(JsObject paramProperty: paramProperties) { |
| ((JsObjectImpl)paramProperty).resolveTypes(docHolder); |
| } |
| } |
| } |
| |
| // @Override |
| // public String toString() { |
| // return "JsFunctionImpl{" + "declarationName=" + getDeclarationName() + ", parent=" + getParent() + ", kind=" + kind + ", parameters=" + parameters + ", returnTypes=" + returnTypes + '}'; |
| // } |
| |
| @Override |
| protected void correctTypes(String fromType, String toType) { |
| super.correctTypes(fromType, toType); |
| String typeR; |
| String typeFQN; |
| Set<TypeUsage> copy = new HashSet<TypeUsage>(returnTypes); |
| for (TypeUsage type : copy) { |
| typeFQN = type.getType(); |
| typeR = replaceTypeInFQN(typeFQN, fromType, toType); |
| if (typeR != null) { |
| returnTypes.remove(type); |
| returnTypes.add(new TypeUsage(typeR, type.getOffset(), type.isResolved())); |
| } |
| } |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder(); |
| sb.append(getDeclarationName().getName()).append("()"); |
| return sb.toString(); |
| } |
| |
| public boolean isStrict() { |
| return isStrict; |
| } |
| |
| public void setStrict(boolean isStrict) { |
| this.isStrict = isStrict; |
| } |
| |
| } |
